Vraag De beste (en veiligste) manier om een ​​git branch samen te voegen met de master


Een nieuwe tak van master is gemaakt, we noemen het test.

Er zijn verschillende ontwikkelaars die zich committeren aan master of maak andere takken en voeg er later in samen master.

Laten we zeggen werk aan test duurt enkele dagen en je wilt het continu houden test bijgewerkt met commits binnen master.

ik zou doen git pull origin master van test.

Vraag 1: Is dit de juiste aanpak? Andere ontwikkelaars hadden gemakkelijk aan dezelfde bestanden kunnen werken als ik tussen haakjes heb gewerkt.


Mijn werk aan test is klaar en ik ben klaar om het samen te voegen met master. Hier zijn de twee manieren die ik kan bedenken:

EEN: 

git checkout test
git pull origin master
git push origin test
git checkout master
git pull origin test 

B: 

git checkout test
git pull origin master
git checkout master
git merge test

Ik gebruik het niet --rebase omdat vanuit mijn mening rebase de wijzigingen zal krijgen master en daar bovenop de mijn te stapelen, vandaar dat het de veranderingen die andere mensen gemaakt hebben kan overschrijven.

Vraag 2: Welke van deze twee methoden is goed? Wat is het verschil daar?

Het doel van dit alles is om mijn test tak bijgewerkt met de dingen die gebeuren in master en later kon ik ze weer samenvoegen master in de hoop de tijdlijn zo lineair mogelijk te houden.


1463
2018-04-09 00:01


oorsprong


antwoorden:


Hoe ik dit zou doen

git checkout master
git pull origin master
git merge test
git push origin master

Als ik een lokale vestiging heb van een externe, voel ik me niet op mijn gemak bij het samenvoegen van andere takken dan deze met de afstandsbediening. Ook zou ik mijn veranderingen niet pushen, totdat ik blij ben met wat ik wil pushen en ik ook helemaal niet zou pushen, die alleen voor mij en mijn lokale repository zijn. In jouw beschrijving lijkt het dat test is alleen voor jou? Dus geen reden om het te publiceren.

git probeert altijd de veranderingen van jou en anderen te respecteren, en dat zal ook zo zijn --rebase. Ik denk niet dat ik het op de juiste manier kan uitleggen, dus kijk eens het Git-boek - Rebasing of git-ready: intro in rebasen voor een kleine beschrijving. Het is een vrij leuke functie


2158
2018-04-09 00:45



Dit is een heel praktische vraag, maar alle bovenstaande antwoorden zijn niet praktisch.

Graag willen

git checkout master
git pull origin master
git merge test
git push origin master

Deze aanpak heeft twee problemen:

  1. Het is onveilig, omdat we niet weten of er conflicten zijn tussen de testbranche en de mastertak.

  2. Het "knijp" alle test commits in een samenvoeg commit op master; dat wil zeggen op de mastertak, we kunnen niet alle logs van de veranderingstest zien.

Dus, als we vermoeden dat er een aantal conflicten zouden zijn, kunnen we volgende git-operaties hebben:

git checkout test
git pull 
git checkout master
git pull
git merge --no-ff --no-commit test

Test merge voor commit, vermijd een fast-forward commit van --no-ff,

Als er een conflict is opgetreden, kunnen we uitvoeren git status om details over de conflicten te controleren en proberen op te lossen

git status

Zodra we de conflicten hebben opgelost, of als er geen conflict is, we commit en push hen

git commit -m 'merge test branch'
git push

Maar op deze manier verliest de geschiedenis van wijzigingen die in de testtak zijn geregistreerd en zou master branch moeilijk zijn voor andere ontwikkelaars om de geschiedenis van het project te begrijpen.

Dus de beste methode is die we moeten gebruiken rebase in plaats van merge (Stel dat we in deze tijd de brancheconflicten hebben opgelost).

Hieronder vindt u een eenvoudig voorbeeld, voor geavanceerde bewerkingen raadpleegt u http://git-scm.com/book/en/v2/Git-Branching-Rebasing

git checkout master
git pull
git checkout test
git pull
git rebase -i master
git checkout master
git merge test

Jazeker, als je het bovendeel hebt voltooid, worden alle commits van de Test branch verplaatst naar het hoofd van de Master branch. Het grote voordeel van rebasen is dat je een lineaire en veel schonere projectgeschiedenis krijgt.

Het enige dat u moet vermijden, is: nooit gebruiken rebase op een publieke tak, zoals een mastertak.

zoals volgende bewerking:

git checkout master
git rebase -i test

doe nooit deze operaties.

Details voor https://www.atlassian.com/git/tutorials/merging-vs-rebasing/the-golden-rule-of-rebasing

bijlage:


260
2018-03-14 12:13



Noch een rebase, noch een samenvoeging moeten iemands wijzigingen overschrijven (tenzij u ervoor kiest om dit te doen bij het oplossen van een conflict).

De gebruikelijke aanpak tijdens het ontwikkelen is

git checkout master
git pull
git checkout test
git log master.. # if you're curious
git merge origin/test # to update your local test from the fetch in the pull earlier

Wanneer je klaar bent om weer samen te voegen met de meester,

git checkout master
git log ..test # if you're curious
git merge test
git push

Als je je zorgen maakt over iets breken in de samenvoeging, git merge --abort is er voor jou.

Het gebruik van duwen en trekken als een manier om samen te voegen, is dwaas. Ik weet ook niet waarom je de test naar herkomst pusht.


73
2018-04-10 00:17



behalve KingCrunches antwoord, Ik stel voor om te gebruiken

git checkout master
git pull origin master
git merge --squash test
git commit
git push origin master

Je hebt misschien veel commits in de andere branch gemaakt, wat maar één commit in de master branch zou moeten zijn. Om de commit-geschiedenis zo schoon mogelijk te houden, kunt u al uw commits van de testtak squashen in een commit in de mastertak (zie ook: Git: squashen of niet squashen?). Dan kun je het commit-bericht ook herschrijven tot iets heel expressiefs. Iets dat gemakkelijk te lezen en te begrijpen is, zonder in de code te duiken.

bewerken: u bent mogelijk geïnteresseerd in

Dus op GitHub, eindig ik met het volgende voor een functietak mybranch:

Ontvang het laatste nieuws van oorsprong

$ git checkout master
$ git pull origin master

Zoek de samenvoegingsbasishash:

$ git merge-base mybranch master
c193ea5e11f5699ae1f58b5b7029d1097395196f

$ git checkout mybranch
$ git rebase -i c193ea5e11f5699ae1f58b5b7029d1097395196f

Zorg er nu voor dat alleen de eerste is pick, de rest is s:

pick 00f1e76 Add first draft of the Pflichtenheft
s d1c84b6 Update to two class problem
s 7486cd8 Explain steps better

Kies vervolgens een zeer goed commit-bericht en druk op GitHub. Voer vervolgens het pull-verzoek uit.

Na het samenvoegen van het pull-verzoek, kunt u het lokaal verwijderen:

$ git branch -d mybranch

en op GitHub

$ git push origin :mybranch

20
2018-04-21 08:18



Dit is de workflow die ik gebruik tijdens mijn werk bij het team. Het scenario is zoals u beschreven. Ten eerste als ik klaar ben met werken test Ik rebase met meester om in te halen wat er aan meester is toegevoegd gedurende de tijd dat ik aan het werken ben test tak.

git pull -r upstream master

Hierdoor worden de wijzigingen onder de knie genomen sinds u de test vertakken en toepassen en vervolgens de aangebrachte wijzigingen toepassen om 'bovenop' de huidige status van master te testen. Er kunnen hier conflicten optreden als de andere personen wijzigingen hebben aangebracht in dezelfde bestanden die u in de test hebt bewerkt. Als dat het geval is, moet je ze handmatig repareren en vastleggen. Als je dat eenmaal hebt gedaan, is het goed om over te schakelen naar de hoofdtak en samen te voegen testzonder problemen.


3
2018-03-16 22:27



git checkout master
git pull origin master
# Merge branch test into master
git merge test

Na het samenvoegen, als het bestand is gewijzigd, zal het foutbericht "Conflict oplossen" worden weergegeven wanneer je het samenvoegt

Dus dan moet je eerst al je conflicten oplossen, je moet opnieuw al je veranderingen vastleggen en dan pushen

git push origin master

Dit is beter doen wie veranderingen in de testtak heeft gedaan, omdat hij wist welke veranderingen hij heeft aangebracht.


1
2018-04-07 08:55