Vervang wijzigingen van master naar branch in Git

In mijn repository heb ik een branch genaamd aqwaar ik aan werk.

Vervolgens heb ik nieuw werk en bugs in mastervastgelegd.

Wat is de beste manier om die commits in de aqbranch te krijgen? Maak nog een nieuwe branch van masteren merge deze met aq?

Antwoord 1, autoriteit 100%

Bekijk de aqbranch, en rebase van master.

git checkout aq
git rebase master

Antwoord 2, autoriteit 37%

Je zou gewoon git merge origin/mastermoeten kunnen gebruiken als je in je aq branch zit.

git checkout aq
git merge origin/master

Antwoord 3, autoriteit 11%

Eerst uitchecken om te beheersen:

git checkout master

Voer alle wijzigingen, hotfix en commits uit en push je master.

Ga terug naar je branch, ‘aq’, en merge master erin:

git checkout aq
git merge master

Uw branch zal up-to-date zijn met master. Een goed en eenvoudig voorbeeld van samenvoegen is 3.2 Git Branching – Basic Branching en Samenvoegen.

Antwoord 4, autoriteit 3%

Er is geen garantie dat de hoofdbugfixes niet tussen andere commits zijn, dus je kunt niet gewoon samenvoegen. Doen

git checkout aq
git cherry-pick commit1
git cherry-pick commit2
git cherry-pick commit3
...

ervan uitgaande dat deze commits de bugfixes vertegenwoordigen.

Bewaar bugfixes vanaf nu in een aparte branch. U kunt gewoon

git merge hotfixes

wanneer je ze allemaal naar de reguliere dev branch wilt rollen.

Antwoord 5, autoriteit 2%

Ofwel cherry-pickde relevante commits in branch aqof merge branch masterin branch aq.

Antwoord 6, autoriteit 2%

Samenvoegen met aq

git checkout master
git pull
git checkout aq
git merge --no-ff master
git push

Antwoord 7, autoriteit 2%

Deze (van hier) werkte voor mij:

git checkout aq
git pull origin master
...
git push

Citaat:

git pull origin masterhaalt de inhoud van de master op en voegt deze samen
branch met je branch en creëert een merge commit. Als die er zijn
samenvoegconflictenu wordt in dit stadium op de hoogte gesteld en u moet oplossen
de merge commit voordat je verder gaat. Wanneer u klaar bent om uw
lokale commits, inclusief je nieuwe merge commit, naar de externe server,
voer git pushuit.

Antwoord 8

Eenvoudige manier

# 1. Create a new remote branch A base on last master
# 2. Checkout A
# 3. Merge aq to A

Antwoord 9

Voor mij had ik al veranderingen doorgevoerd en ik wilde het laatste nieuws van de basistak. Ik kon rebaseniet doen, en cherry-pickzou een eeuwigheid hebben geduurd, dus deed ik het volgende:

git fetch origin <base branch name>  
git merge FETCH_HEAD

dus in dit geval:

git fetch origin master  
git merge FETCH_HEAD

Antwoord 10

U hebt een paar opties. git rebase master aqop de tak die de begindnamen behouden, maar niet opnieuw brengt als dit een afgelegen filiaal is. U kunt git merge master aqals u niet om de naam van het plegen te houden. Als u de CITE-namen wilt behouden en het is een afstandsbediening git cherry-pick <commit hash>De commits op uw tak.

Antwoord 11

bewerken:

Mijn antwoord hieronder documenten een manier om masterin te voegen in aq, waar als u de details van de samenvoeging bekijkt, de wijzigingen op aqVóór de samenvoeging, niet de wijzigingen die zijn aangebracht op master. Ik heb me gerealiseerd dat dat waarschijnlijk niet wat je wilt, zelfs als je denkt dat het is!

Alleen:

git checkout aq
git merge master

is prima.

Ja, deze eenvoudige samenvoeging toont aan dat de wijzigingen van masterzijn gemaakt naar aqop dat moment, niet andersom; Maar dat is goed – omdat dat is wat er gebeurde! Later, wanneer u uiteindelijk uw tak in mastersamenvoegt, is dat wanneer een samenvoeging ten slotte al uw wijzigingen zal tonen zoals gedaan in master(die precies is wat u wilt, en Is de commit waar mensen sowieso te verwachten te vinden).

Ik heb het gecontroleerd en de aanpak hieronder toont ook precies dezelfde wijzigingen (alle wijzigingen die zijn aangebracht op aqsinds de originelesplitsing tussen aqen master) als de normale benadering hierboven, wanneer je uiteindelijk alles weer samenvoegt naar master. Dus ik denk dat het enige echte nadeel (behalve dat het te complex en niet-standaard is… :-/ ) is dat als je recente wijzigingen terugdraait met git reset --hard HEAD~<n>en dit gaat voorbij de samenvoeging, dan rolt de onderstaande versie terug naar de ‘verkeerde’ branch, die je met de hand moet repareren (bijv. met git reflog& git reset --hard [sha]).

[Dus wat ik eerder dacht was dat:]

Er is een probleem met:

git checkout aq
git merge master

omdat de wijzigingen die worden getoond in de merge-commit (bijvoorbeeld als je nu of later kijkt in Github, Bitbucket of je favoriete lokale git-geschiedenisviewer) de wijzigingen zijn die op master zijn gemaakt, wat misschien niet is wat je wilt.

Aan de andere kant

git checkout master
git merge aq

toont de wijzigingen die zijn aangebracht in aq, wat waarschijnlijk iswat u wilt. (Of in ieder geval, het is vaak wat ik wil!) Maar de merge die de juiste wijzigingen laat zien, staat op de verkeerde branch!

Hoe ermee om te gaan?!

Het volledige proces, eindigend met een merge-commit die de wijzigingen toont die zijn gemaakt op aq (zoals in de tweede merge hierboven), maar waarbij de merge de aq-branch beïnvloedt, is:

git checkout master
git merge aq
git checkout aq
git merge master
git checkout master
git reset --hard HEAD~1
git checkout aq

Dit: voegt aq samen met master, spoelt dezelfde merge vooruit naar aq, maakt het ongedaan met master en zet je weer terug op aq!

Ik heb het gevoel dat ik iets mis – dit lijkt iets te zijn dat je duidelijk zou willen, en iets dat moeilijk te doen is.

Rebase is ook NIET equivalent. Het verliest de tijdstempels en identiteit van de commits gemaakt op aq, wat ook niet is wat ik wil.

Antwoord 12

U kunt dit ook doen door een enkele regel uit te voeren.
git merge aq master

Dit komt overeen met

git checkout aq
git merge master

Antwoord 13

Scenario:

• Ik heb een branch gemaakt van master, zeg branch-1 en trok het naar mijn local.
• Mijn vriend heeft een branch gemaakt van master zeg branch-2.
• Hij heeft een aantal codewijzigingen doorgevoerd om te masteren.
• Nu wil ik die wijzigingen van de master-branch naar mijn lokale branch brengen.

Oplossing

git stash // to save all existing changes in local branch
git checkout master // Switch to master branch from branch-1
git pull // take changes from the master
git checkout branch-1 // switchback to your own branch
git rebase master // merge all the changes and move you git head  forward
git stash apply // reapply all you saved changes 

U kunt conflicten in uw bestand vinden na het uitvoeren van “git stash apply”. Je moet het handmatig repareren en nu ben je klaar om te pushen.