web-dev-qa-db-fra.com

Comment fusionner mes modifications locales non validées dans une autre branche Git?

Comment puis-je faire ce qui suit dans Git?

Ma branche actuelle est branch1 et j'ai apporté des modifications locales. Cependant, je réalise maintenant que je voulais réellement appliquer ces modifications à branch2. Existe-t-il un moyen d'appliquer/de fusionner ces modifications afin qu'elles deviennent des modifications locales sur branche2 sans les valider sur branche1?

gitbranch
603
solsberg

Puisque vos fichiers ne sont pas encore validés dans _branch1_:

_git stash
git checkout branch2
git stash pop
_

ou

_git stash
git checkout branch2
git stash list       # to check the various stash made in different branch
git stash apply x    # to select the right one
_

Comme indiqué par benjohn (voir _git stash_ page de manuel ):

Pour cacher également les fichiers non suivis (nouvellement ajoutés), ajoutez l'argument _-u_, afin que:

_git stash -u
_
871
VonC

Stashing, commits temporaires et rebasing peuvent tous être exagérés. Si vous n'avez pas encore ajouté les fichiers modifiés à l'index, vous pourrez peut-être simplement extraire l'autre branche.

git checkout branch2

Cela fonctionnera tant qu'aucun fichier que vous modifiez n'est différent entre branch1 et branch2. Cela vous laissera sur branch2 avec vous, les modifications de travail seront préservées. S'ils sont différents, vous pouvez alors spécifier que vous souhaitez fusionner vos modifications locales avec les modifications introduites en changeant de branche avec l'option -m à la caisse.

git checkout -m branch2

Si vous avez ajouté des modifications à l'index, vous devez d'abord annuler ces modifications en les réinitialisant. (Ceci préservera votre copie de travail, il supprimera simplement les modifications planifiées.)

git reset
84
CB Bailey

Une alternative plus courte à l'approche stash mentionnée précédemment serait:

Déplacer temporairement les modifications dans une réserve.

  1. git stash

Créez et basculez vers une nouvelle branche, puis placez-y la réserve en une seule étape.

  1. git stash branch new_branch_name

Ensuite, il ne reste que add et commit les modifications apportées à cette nouvelle branche.

12
rbento

ATTENTION: Pas pour les débutants git.

Cela arrive assez dans mon flux de travail que j'ai presque essayé d'écrire une nouvelle commande git pour cela. Le flux habituel git stash est le chemin à parcourir mais est un peu gênant. Je fais d’abord un nouveau commit d’abord si j’ai examiné les modifications, toutes les informations me reviennent à l’esprit et il est préférable de commencer simplement git commit ce que j'ai trouvé (en général, un correctif appartenant au maître que je découvre en travaillant sur une branche de fonctionnalité).

Il est également utile - si vous rencontrez souvent ce type de situation - d’avoir n autre répertoire de travail à côté de votre répertoire actuel, sur lequel la branche master est toujours extraite.

Alors, comment cela se passe-t-il?

  1. git commit les modifications tout de suite avec un bon message de validation.
  2. git reset HEAD~1 pour annuler la validation de la branche actuelle.
  3. (facultatif) continuez à travailler sur la fonctionnalité.

Parfois plus tard (de manière asynchrone), ou immédiatement dans une autre fenêtre de terminal:

  1. cd my-project-master qui est un autre WD partageant le même .git
  2. git reflog pour trouver le correctif que je viens de faire.
  3. git cherry-pick SHA1 du commit.

Facultativement (toujours asynchrone), vous pouvez ensuite rebaser (ou fusionner) votre branche de fonctionnalité pour obtenir le correctif, généralement lorsque vous êtes sur le point de soumettre un PR et que vous avez déjà nettoyé votre branche de fonctionnalité et WD:

  1. cd my-project qui est le WD principal sur lequel je travaille.
  2. git rebase master pour obtenir les corrections de bugs.

De cette façon, je peux continuer à travailler sur la fonctionnalité sans interruption et ne pas avoir à m'inquiéter de git stash rien ou de devoir nettoyer mon WD avant un git checkout (puis avoir à nouveau le contrôle de la branche de fonctionnalité.) et encore toutes mes corrections de bugs vont à master au lieu de caché dans ma branche de fonctionnalité.

IMO git stash et git checkout est une véritable PIA lorsque vous êtes en train de travailler sur une grosse fonctionnalité.

8
chakrit

S'il s'agissait de modifications engagées, vous devriez jeter un coup d'œil à git-rebase, mais comme l'a souligné VonC dans son commentaire, lorsque vous parlez de modifications locales, git-stash serait certainement le meilleur moyen de le faire.

2
claf

Les réponses données jusqu'à présent ne sont pas idéales, car elles nécessitent beaucoup de travail inutile pour résoudre les conflits de fusion ou reposent sur de trop nombreuses hypothèses souvent fausses. Voici comment le faire parfaitement. Le lien est à mon propre site.

Comment s’engager dans une branche différente dans git

Vous avez des modifications non validées sur my_branch que vous souhaitez valider en master, sans valider toutes les modifications de my_branch.

Exemple

git merge master
git stash -u
git checkout master
git stash apply
git reset
git add example.js
git commit
git checkout .
git clean -f -d
git checkout my_branch
git merge master
git stash pop

Explication

Commencez par fusionner master dans votre branche, car vous devrez le faire de toute façon, et le moment est bien choisi pour résoudre tous les conflits.

L'option -u (alias --include-untracked) dans git stash -u vous empêche de perdre des fichiers non suivis lorsque vous ferez plus tard git clean -f -d dans master.

Après git checkout master, il est important de NE PAS git stash pop, car vous aurez besoin de cette réserve ultérieurement. Si vous ouvrez le stash créé dans my_branch, puis faites git stash dans master, vous causerez des conflits de fusion inutiles lorsque vous appliquerez ultérieurement ce stash dans my_branch.

git reset efface tout ce qui résulte de git stash apply. Par exemple, les fichiers qui ont été modifiés dans le stash mais n'existent pas dans master sont mis en scène comme des conflits "supprimés par nous".

git checkout . et git clean -f -d ignorent tout ce qui n'est pas validé: toutes les modifications apportées aux fichiers suivis, ainsi que tous les fichiers et répertoires non suivis. Ils sont déjà enregistrés dans la réserve et, s'ils sont laissés dans master, ils provoqueraient des conflits de fusion inutiles lors du retour à my_branch.

Le dernier git stash pop sera basé sur le my_branch d'origine et ne causera donc aucun conflit de fusion. Cependant, si votre stash contient des fichiers non suivis que vous vous êtes engagé à maîtriser, git se plaint de ce qu'il "ne peut pas restaurer les fichiers non suivis à partir de stash". Pour résoudre ce conflit, supprimez ces fichiers de votre arbre de travail, puis git stash pop, git add . et git reset.

1
Vladimir Kornea