La Combinaison De Plusieurs Engage Dans Une Avant De Pousser

Cette question ne concernent pas seulement la façon d'accomplir cette tâche, mais si cela est une bonne ou une mauvaise pratique avec Git.

Considérer que, localement, je fais la plupart du travail sur la branche master, mais j'ai créé un topique branche je vais appeler "topical_xFeature". Dans le processus de travail sur "topical_xFeature" et des allers-retours pour faire d'autres travaux sur la branche master, il s'avère que j'ai fait plus d'un commit sur la "topical_xFeature" de la branche, mais entre chaque commit, je n'ai pas fait de pousser.

Première, envisagez-vous de cette mauvaise pratique? Ne serait-il pas plus sage de rester avec un commit par direction par poussée? Dans ce cas, serait-il bon d'avoir plusieurs s'engage sur une branche avant de pousser un est fait?

Deuxième, comment vais-je accomplir apportant les multiples s'engage sur la topical_xFeature branche dans la branche master pour un coup de pouce? Est une nuisance pour vous inquiétez pas à ce sujet et juste de faire du push où plusieurs s'engage obtenir poussé, ou qu'il est moins gênant de faire en quelque sorte fusionner les commits dans un et ensuite de pousser? Encore une fois, comment faire?

InformationsquelleAutor Todd Hopkinson | 2011-04-19

git workflow

131

Pour votre première question, non, il n'y a rien de mal à pousser plusieurs engage à la fois. De nombreuses fois, vous pouvez les diviser votre travail vers le bas dans un peu de petite taille s'engage, mais seulement de les pousser vers le haut une fois vous vous sentez comme l'ensemble de la série est prêt. Ou vous pourriez faire quelques engage localement tout en étant déconnecté, et vous poussent tous une fois que vous êtes connecté à nouveau. Il n'y a pas de raison de se limiter à un commit à chaque pression.

En général, je trouve que c'est une bonne idée de garder chaque commit un seul, logique, cohérente changement, qui comprend tout ce dont il a besoin pour travailler (donc, il ne laisse pas votre code dans un état rompu). Si vous avez un deux commits, mais ils ne provoquer le code pour être cassé, si vous en seulement appliqué la première, il pourrait être une bonne idée de supprimer le deuxième s'engager dans la première. Mais si vous avez deux commits où chacun fait un changement raisonnable, poussant comme des livraisons séparées est très bien.

Si vous ne voulez squash plusieurs commits ensemble, vous pouvez utiliser git rebase -i. Si vous êtes sur la branche topical_xFeature, vous devez exécuter git rebase -i master. Cela va ouvrir une fenêtre de l'éditeur, avec un ensemble de commits répertoriés préfixé par pick. Vous pouvez modifier tous, mais le premier à squash, qui va indiquer à Git de garder tous ces changements, mais la courge dans le premier commit. Après vous avez fait cela, découvrez master et de fusion dans votre branche:
```
git checkout topical_xFeature
git rebase -i master
git checkout master
git merge topical_xFeature
```
Alternativement, si vous voulez juste de squash tout en topical_xFeature en master, vous avez juste à faire ce qui suit:
```
git checkout master
git merge --squash topical_xFeature
git commit
```
Celui que vous choisissez est à vous. En général, je ne voudrais pas vous soucier d'avoir plusieurs petits commits, mais parfois vous ne voulez pas vous embêter avec extra mineur commet, il vous suffit de les écraser dans un.
- git merge --squash! la droite. +1
- Après je fusionne avec --squash, je ne suis pas en mesure de supprimer la rubrique de la direction, avec git branch -d topic. Pourquoi est-git pas en mesure d'identifier que tous les changements sont fusionnées?
- Parce que Git détecte si des correctifs sont regroupées selon qu'ils apparaissent dans l'histoire de la branche donnée. L'écrasement de mise à jour des changements; ils deviennent un nouveau commit, et tandis que le nouveau commit qui arrive à faire la même chose que les autres, Git ne peut pas dire qu'il ne peut dire si les commits sont les mêmes si ils ont la même commettre ID (SHA-1). Donc, une fois que vous écraser, vous devez indiquer à git pour supprimer l'ancienne branche avec git branch -D topic à force de le supprimer.
InformationsquelleAutor Brian Campbell
62

C'est la façon dont je le suivent généralement de combiner plusieurs s'Engage dans un seul s'engager avant que j'appuie sur le code.

Pour y parvenir, je vous suggère d'utiliser 'squash' concept fourni par GIT.

Suivez les étapes ci-dessous.

1) git rebase -i master (au lieu de maître vous pouvez également utiliser un spécifique commettre)

ouvrir le rebase interactif de l'éditeur, où il montrera tous vos commits. Fondamentalement, lorsque vous avez besoin d'identifier les commits qui vous souhaitez fusionner dans un seul commit.

Imaginez ce sont vos commits et montré quelque chose comme cela dans l'éditeur.
```
pick f7f3f6d changed my name a bit    
pick 310154e updated README formatting and added blame   
pick a5f4a0d added cat-file  
```
Il est important de noter que ces révisions sont répertoriés dans l'ordre opposé à celui que vous voyez normalement entre eux à l'aide de la commande log. Les moyens, les plus âgés commit sera affiché en premier.

2) Changement de 'choix' pour 'squash' pour la dernière commis des changements. quelque chose comme illustré ci-dessous. Donc, vos 2 dernières validations seront fusionnées avec la première.
```
pick f7f3f6d changed my name a bit         
squash 310154e updated README formatting and added blame   
squash a5f4a0d added cat-file
```
Vous pouvez également utiliser la forme courte si vous avez beaucoup de engage à combiner:
```
p f7f3f6d changed my name a bit         
s 310154e updated README formatting and added blame   
s a5f4a0d added cat-file
```
pour l'édition utilisez "je", il permettra à l'éditeur pour l'insertion. Gardez à l'esprit tout en haut(les plus anciennes) s'engager à ne peut pas être écrasé comme il n'y a pas de précédent s'engager à combiner avec. Donc, il doit être repris ou 'p'. Utiliser " Esc " pour quitter le mode insertion.

3) Maintenant, économiser de l'éditeur avec la commande suivante.
:wq

Lorsque vous enregistrez, vous avez un seul commit qui introduit les modifications de tous les trois précédentes s'engage.

Espère que cela va vous aider.
- C'est peut-être évident pour les autres, mais, quand vous dites "git rebase -i", vous devez également préciser qui vous engage départ. C'est quelque chose que je ne savais pas quand j'ai essayé de suivre cet exemple. Ainsi, dans cet exemple, il serait "git rebase -i xxxxx xxxxx s'engager à droite avant f7f3f6d dans l'ordre chronologique. Une fois que j'ai compris, tout a fonctionné exactement comme décrit ci-dessus.
- C'est intéressant @nukeguy, je n'ai pas de problème de ne pas spécifier de spécifique de commettre. Il a juste manqué de ce qui était là.
InformationsquelleAutor Kondal Kolipaka
11

Première: rien ne vous dit qu'un commit par branche par push: une poussée est une publication mécanisme vous permettant de publier une histoire locale (c'est à dire une collection de commits) sur une distance de repo.

Deuxième: un git merge --no-ff topical_xFeature serait d'enregistrer sur le maître comme un seul commit votre sujet de travail, avant de pousser master.

(De cette façon, vous gardez topical_xFeature autour pour d'autres évolutions, que vous pouvez enregistrer sur master comme un seul nouveau commit sur la prochaine fusion --no-ff.

Si se débarrasser de topical_xFeature est le but, alors git merge --squash est la bonne option, comme détaillé dans Brian Campbell's réponse.)
- Je pense que --squash, pas --no-ff est ce que vous voulez. --no-ff serait de créer un commit de fusion, mais aussi de laisser tous les commits de topical_xFeature.
- Je suis d'accord et upvoted votre réponse, mais j'ai d'abord pensé à l'option --no-ff option parce que je voulais garder topical_feature direction, et il vous suffit d'enregistrer un seul commit sur master branche.
InformationsquelleAutor VonC
8

Passer à la branche master et assurez-vous que vous êtes à jour.
```
git checkout master
```
git fetch ce sera peut-être nécessaire (en fonction de votre git config) pour recevoir des mises à jour sur origin/master
```
git pull
```
De fusion de la branche dans la branche master.
```
git merge feature_branch
```
Réinitialiser la branche master à l'origine de l'état.
```
git reset origin/master
```
Git considère désormais toutes les modifications que unstaged changements.
Nous pouvons ajouter à ces changements comme un commit.
L'ajout d' . également ajouter sans traces de fichiers.
```
git add --all

git commit
```
Ref: https://makandracards.com/makandra/527-squash-several-git-commits-into-a-single-commit
- cette réponse est facile à suivre et vraiment facile à visualiser.
InformationsquelleAutor shiva kumar
3

1) d'Abord choisir les commit que vous voulez que tout est venu après.
```
git reflog
5976f2b HEAD@{0}: commit: Fix conflicts
80e85a1 HEAD@{1}: commit: Add feature
b860ddb HEAD@{2}: commit: Add something
```
2) Réinitialisation de votre choix sur la tête (j'ai choisi la TÊTE de@{2})
```
git reset b860ddb --soft
```
3) git status (juste pour être sûr)

4) Ajouter votre nouveau commit
```
git commit -m "Add new commit"
```
Remarque: HEAD@{0} & HEAD@{1} Sont maintenant fusionnés en 1 s'engager, ce qui peut être fait pour de multiples s'engage également.

git reflog à nouveau s'afficher:
```
git reflog
5976f2b HEAD@{0}: commit: Add new commit
b860ddb HEAD@{1}: commit: Add something
```
InformationsquelleAutor Eddy Ekofo

Vous devez vous connecter pour publier un commentaire.