Comment diviser le dernier commit en deux dans Git

J'ai deux branches, maître et forum et j'ai juste fait quelques modifications dans forum branche, que je tiens à piocher dans maître. Mais malheureusement, la validation, je veux cherry-pick contient également quelques modifications que je ne veux pas.

La solution serait probablement d'une certaine manière de suppression erronée de s'engager et de le remplacer par deux des livraisons séparées, l'une avec les modifications que je veux choisir en master, et d'autres qui ne leur appartient pas.

J'ai essayé de faire

git reset --hard HEAD^

supprimé tous les changements, j'ai donc dû revenir avec

git reset ORIG_HEAD

Donc ma question est, quelle est la meilleure façon de split dernier commit en deux s'engage?

InformationsquelleAutor Jakub Arnold | 2009-09-17

git version-control

327

Vous devez utiliser l'index. Après avoir fait un mixte de réinitialisation ("git reset TÊTE^"), ajouter
la première série de changements dans l'index, puis les valider. Puis engagez-le
le repos.

Vous pouvez utiliser "git add" pour mettre toutes les modifications apportées à un fichier à l'index. Si vous
ne voulez pas de mettre en scène chaque modification apportée à un fichier, seulement certains d'entre eux, vous
pouvez utilisez "git add -p".

Voyons un exemple. Supposons que j'avais un fichier nommé monfichier, qui contient
le texte suivant:
```
something
something else
something again
```
Je l'ai modifié dans mon dernier commit de sorte que maintenant il ressemble à ceci:
```
1
something
something else
something again
2
```
Maintenant, je décide que je veux la couper en deux, et je veux l'insertion de la
première ligne à être dans le premier commit, et l'insertion de la dernière ligne à
dans la deuxième commettre.

J'ai d'abord revenir à la TÊTE de la mère, mais je veux garder les modifications dans le système de fichiers,
j'ai donc utilisez "git reset" sans argument (qui va faire un soi-disant "mixte"
réinitialiser):
```
$ git reset HEAD^
myfile: locally modified
$ cat myfile
1
something
something else
something again
2
```
Maintenant je utilisez "git add -p" pour ajouter les modifications que je veux commettre à l'index (=je
stade de mer). "git add -p" est un outil interactif qui vous interroge au sujet de ce que
les modifications apportées au fichier faut-il ajouter à l'index.
```
$ git add -p myfile
diff --git a/myfile b/myfile
index 93db4cb..2f113ce 100644
--- a/myfile
+++ b/myfile
@@ -1,3 +1,5 @@
+1
 something
 something else
 something again
+2
Stage this hunk [y,n,a,d,/,s,e,?]? s    # split this section into two!
Split into 2 hunks.
@@ -1,3 +1,4 @@
+1
 something
 something else
 something again
Stage this hunk [y,n,a,d,/,j,J,g,e,?]? y  # yes, I want to stage this
@@ -1,3 +2,4 @@
 something
 something else
 something again
+2
Stage this hunk [y,n,a,d,/,K,g,e,?]? n   # no, I don't want to stage this
```
Puis-je commettre ce premier changement:
```
$ git commit -m "Added first line"
[master cef3d4e] Added first line
 1 files changed, 1 insertions(+), 0 deletions(-)
```
Maintenant, je peux commettre tous les autres changements (à savoir le chiffre "2" mettre dans la dernière ligne):
```
$ git commit -am "Added last line"
[master 5e284e6] Added last line
 1 files changed, 1 insertions(+), 0 deletions(-)
```
Nous allons consulter le journal pour voir ce qui s'engage, nous avons:
```
$ git log -p -n2 | cat
Commit 5e284e652f5e05a47ad8883d9f59ed9817be59d8
Author: ...
Date: ...

    Added last line

Diff --git a/myfile b/myfile
Index f9e1a67..2f113ce 100644
--- a/myfile
+++ b/myfile
@@ -2,3 +2,4 @@
 something
 something else
 something again
+2

Commit cef3d4e0298dd5d279a911440bb72d39410e7898
Author: ...
Date: ...

    Added first line

Diff --git a/myfile b/myfile
Index 93db4cb..f9e1a67 100644
--- a/myfile
+++ b/myfile
@@ -1,3 +1,4 @@
+1
 something
 something else
 something again
```
- J'ai été habitués à git à partir Mercurial au cours de la dernière semaine et demi, et il y a un raccourci pratique de commande git reset [--patch|-p] <commit> que vous pouvez utiliser pour vous épargner la peine d'avoir à git add -p après la réinitialisation. Suis-je le droit? À l'aide de git 1.7.9.5.
- Voici un peu plus sur cette technique, y compris la relocalisation si c'était un vieux commettre, ou vous avez besoin de changer N engage à M s'engage à: emmanuelbernard.com/blog/2014/04/14/... .
InformationsquelleAutor hcs42
81

Objectifs:
- Je veux diviser un passé commit (splitme) en deux.
- Je veux maintenir le message de commit.
Plan:
1. rebase interactif à partir d'un avant splitme.
2. modifier splitme.
3. Réinitialiser les fichiers de split dans une deuxième validation.
4. Modifier commettre, le maintien de message, modifier si nécessaire.
5. Ajouter les fichiers séparés à partir de la première validation.
6. S'engager dans un nouveau message.
7. Continuer rebase.
Le rebase étapes (1 & 7) peut être ignorée si l' splitme est la plus récente s'engager.
```
git rebase -i splitme^
# mark splitme commit with 'e'
git reset HEAD^ -- $files
git commit --amend
git add $files
git commit -m "commit with just some files"
git rebase --continue
```
Si je voulais le diviser les fichiers pour être la première engagée, alors je dirais rebase -i nouveau et changer l'ordre
```
git rebase -i splitme^
# swap order of splitme and 'just some files'
```
- git reset HEAD^ était la pièce manquante du puzzle. Fonctionne bien avec -p trop. Merci!
- Il est important de noter la -- $files argument git reset. Avec les chemins de passé, git reset restaure les fichiers à l'état de référence s'engager mais ne changera s'engage. Si vous le laissez à l'extérieur des sentiers, puis vous "perdre" le commit que vous voulez modifier dans la prochaine étape.
- merci à vous et Simba!
- Cette méthode vous évite d'avoir à copier et coller votre premier message de commit encore, par rapport à la accepté de répondre.
- Aussi: si vous souhaitez réinitialiser tous les fichiers, il suffit d'utiliser git reset HEAD^ -- .. Très étonnamment, c'est pas exactement le comportement de git reset HEAD^.
InformationsquelleAutor spazm
52

À changer le cours s'engager dans deux commits, vous pouvez faire quelque chose comme ce qui suit.

Soit:
```
git reset --soft HEAD^
```
Cela permet d'annuler le dernier commit, mais laisse tout mis en scène. Vous pouvez ensuite unstage certains fichiers:
```
git reset -- file.file
```
Éventuellement restage parties de ces fichiers:
```
git add -p file.file
```
Faire un nouveau premier commit:
```
git commit
```
La scène et de commettre le reste des modifications dans un deuxième commit:
```
git commit -a
```
Ou:

Annuler et unstage tous les changements survenus depuis le dernier commit:
```
git reset HEAD^
```
Sélectivement stade de la première série de changements:
```
git add -p
```
Commettre:
```
git commit
```
Commettre le reste de l'changements:
```
git commit -a
```
(Dans une autre étape, si vous aviez annulé un commit que l'ajout d'un nouveau fichier et que vous souhaitez ajouter à la deuxième commit, vous devrez ajouter manuellement comme commit -a seulement les étapes des changements de suivi des dossiers.)

InformationsquelleAutor CB Bailey
22

Exécuter git gui, sélectionnez l'option "Modifier le dernier commit" bouton radio, et unstage (Commit > Unstage De Commettre, ou Ctrl-U) les modifications que vous ne voulez pas aller en premier commit. Je pense que c'est la meilleure façon d'aller à ce sujet.

Une autre chose que vous pourriez faire est de choisir le changement sans commettre (git cherry-pick -n) et puis, que ce soit manuellement ou avec git gui sélectionnez les changements souhaités avant de s'engager.

InformationsquelleAutor Michael Krelin - hacker
15
```
git reset HEAD^
```
le-hard est ce qui tue vos modifications.

InformationsquelleAutor semanticart
13

Je suis surpris que personne n'a suggéré git cherry-pick -n forum. Cela mettra en scène les changements de la dernière forum s'engager, mais pas commettre eux - vous pouvez ensuite reset loin les changements que vous n'avez pas besoin et de s'engager à ce que vous souhaitez conserver.

InformationsquelleAutor dahlbyk
3

Le double-revenir-squash méthode
1. Faire un autre commit qui supprime les modifications indésirables. (Si c'est par fichier, c'est vraiment facile: git checkout HEAD~1 -- files with unwanted changes et git commit. Si non, les fichiers avec un mélange de changements peuvent être partiellement mises en scène git reset file et git add -p file comme une étape intermédiaire.) Appelons cela le revenir.
2. git revert HEAD – Faire encore un autre de commettre, qui ajoute le dos les changements non désirés. C'est le double-revenir
3. De la 2 vous engage maintenant squash le premier sur le commettre à split (git rebase -i HEAD~3). Ce commit devient maintenant libre de changements non désirés, pour ceux qui sont dans la deuxième commettre.
Avantages
- Préserve le message de commit
- Fonctionne même si la validation de split n'est pas le dernier. Il exige seulement que les changements non désirés ne sont pas en conflit avec, plus tard, s'engage
InformationsquelleAutor user2394284
1

Puisque vous êtes cherry-picking, vous pouvez:
1. cherry-pick avec --no-commit ajout de l'option.
2. reset et l'utilisation add --patch, add --edit ou tout simplement add à la scène que vous souhaitez conserver.
3. commit la mise en scène des changements.
  - La ré-utilisation d'original message de commit, vous pouvez ajouter --reuse-message=<old-commit-ref> ou --reedit-message=<old-commit-ref> options pour la commit commande.
4. Souffler unstaged changements avec reset --hard.
Une autre façon, la préservation ou de l'édition de l'original message de commit:
1. cherry-pick l'original s'engager comme d'habitude.
2. Annuler les modifications que vous ne voulez pas et l'utilisation add à l'étape de la reprise.
  - Cette étape serait facile si vous êtes en train de supprimer ce que vous avez ajouté, mais un peu difficile si vous ajoutez ce que vous avez supprimé ou d'inverser un changement.
3. commit --amend à l'effet de la reprise sur la cerise cueillies à la commettre.
  - Vous aurez le même message de commit de nouveau, que vous pouvez conserver ou de les réviser au besoin.
InformationsquelleAutor ADTC
0

Cela pourrait être une autre solution ciblée pour les cas où il y a une énorme s'engager et d'une petite quantité de fichiers doit être déplacé dans un nouveau commit. Cela ne fonctionnera que si un ensemble de <path> fichiers doivent être extraits de le dernier commit à la TÊTE et tous déplacé vers un nouveau commit. Si plusieurs commits sont nécessaires, les autres solutions peuvent être utilisées.

D'abord faire des pièces dans la mise en scène et unstaged secteurs qui contiennent les modifications pour revenir le code avant la modification et après la modification respectivement:
```
git reset HEAD^ <path>

$ git status
On branch <your-branch>
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

        modified:   <path>

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

        modified:   <path>
```
Pour comprendre ce qui va se passer (flèche et les commentaires ne font pas partie de la commande):
```
git diff --cached   -> show staged changes to revert <path> to before HEAD
git diff            -> show unstaged changes to add current <path> changes
```
Revenir <path> changements dans le dernier commit:
```
git commit --amend  -> reverts changes on HEAD by amending with staged changes
```
Créer de nouveaux engager avec <path> changements:
```
git commit -a -m "New Commit" -> adds new commit with unstaged changes
```
Ce qui a pour effet de créer un nouveau commit qui contient les modifications extrait du dernier commit.

InformationsquelleAutor Jose Cifuentes

Vous devez vous connecter pour publier un commentaire.

Objectifs:

Plan:

Le double-revenir-squash méthode

Avantages