Laten we zeggen dat we de volgende situatie in Git hebben:

1. A Geplotte repository:

   mkdir GitTest2
   cd GitTest2
   git init
   

2. Enkele aanpassingen in de master vinden plaats en betrokken:

   echo "On Master" > file
   git commit -a -m "Initial commit"
   

3. Feature1 vertakte van Master en sommige werk is gedaan:

   git branch feature1
   git checkout feature1
   echo "Feature1" > featureFile
   git commit -a -m "Commit for feature1"
   

4. Ondertussen wordt een bug ontdekt in de mastercode en wordt een hotfix-tak vastgesteld:

   git checkout master
   git branch hotfix1
   git checkout hotfix1
   

5. De bug is vastgelegd in de tak van het hotfix en fuseerde terug in de master (misschien na een pull-aanvraag / code):

   echo "Bugfix" > bugfixFile
   git commit -a -m "Bugfix Commit"
   git checkout master
   git merge --no-ff hotfix1
   

6. Ontwikkeling op functie1 gaat verder:

   git checkout feature1
   

Zeg dat ik de hotfix in mijn functie-tak nodig heb, misschien omdat de fout daar ook voorkomt. Hoe kan ik dit bereiken zonder de commits in mijn functie-filiaal te dupliceren?

Ik wil voorkomen dat u twee nieuwe commits krijgt op mijn feature-tak die geen relatie heeft met de functie-implementatie. Dit lijkt vooral belangrijk voor mij als ik Pull-aanvragen gebruik: al deze commits zullen ook worden opgenomen in het pull-verzoek en moeten worden beoordeeld, hoewel dit al is gedaan (zoals de hotfix al in de master is).

Ik kan geen git merge master --ff-only: “Fatal: niet mogelijk om snel vooruit, aborting te maken.”, Maar ik weet niet zeker of dit me heeft geholpen.

Antwoord 1, Autoriteit 100%

Hoe mergen we de master-branch in de feature-branch? Eenvoudig:

git checkout feature1
git merge master

Het heeft geen zin om hier een snel voorwaartse samenvoeging te forceren, aangezien dit niet kan. Je hebt zowel in de feature-branch als in de master-branch gecommit. Vooruitspoelen is nu onmogelijk.

Bekijk GitFlow. Het is een vertakkingsmodel voor git dat gevolgd kan worden, en dat deed je onbewust al. Het is ook een uitbreiding op Git die enkele commando’s toevoegt voor de nieuwe workflow-stappen die dingen automatisch doen die je anders handmatig zou moeten doen.

Dus wat heb je goed gedaan in je workflow? Je hebt twee branches om mee te werken, je feature1 branch is eigenlijk de “develop” branch in het GitFlow-model.

Je hebt een hotfix-branch van master gemaakt en deze weer samengevoegd. En nu zit je vast.

Het GitFlow-model vraagt je om de hotfix ook samen te voegen met de ontwikkelingstak, wat in jouw geval “feature1” is.

Dus het echte antwoord zou zijn:

git checkout feature1
git merge --no-ff hotfix1

Dit voegt alle wijzigingen die in de hotfix zijn gemaakt toe aan de feature branch, maar alleendie wijzigingen. Ze kunnen conflicteren met andere ontwikkelingswijzigingen in de branch, maar ze zullen niet conflicteren met de master-branch als je de feature-branch uiteindelijk terug naar master merget.

Wees heel voorzichtig met rebasen. Rebase alleen als de wijzigingen die je hebt aangebracht lokaal in je repository zijn gebleven, b.v. je hebt geen branches naar een andere repository gepusht. Rebasen is een geweldig hulpmiddel voor jou om je lokale commits in een bruikbare volgorde te ordenen voordat je het de wereld instuurt, maar achteraf rebasen zal de boel in de war brengen voor de git-beginners zoals jij.

Antwoord 2, autoriteit 42%

Je zou je branch op master moeten kunnen rebasen:

git checkout feature1
git rebase master

Beheer alle conflicten die zich voordoen. Wanneer je bij de commits komt met de bugfixes (reeds in master), zal Git zeggen dat er geen wijzigingen waren en dat ze misschien al waren toegepast. Je gaat dan verder met de rebase (terwijl je de commits die al in master zijn overslaat) met

git rebase --skip

Als je een git loguitvoert op je feature branch, zul je de bugfix commit maar één keer zien verschijnen, en in het master gedeelte.

Voor een meer gedetailleerde discussie, bekijk de Git boekdocumentatie op git rebase(https://git-scm.com/docs/git-rebase) die deze exacte use case dekken.

================ Bewerken voor extra context ====================

Dit antwoord werd specifiek gegeven voor de vraag van @theomega, rekening houdend met zijn specifieke situatie. Let op dit deel:

Ik wil voorkomen dat […] commits op mijn feature branch die geen verband houden met de feature-implementatie.

Het rebasen van zijn private branch op master is precies wat dat resultaat zal opleveren. Daarentegen zou het samenvoegen van master in zijn branch precies doen wat hij specifiek niet wil dat er gebeurt: een commit toevoegen die niet gerelateerd is aan de feature-implementatie waar hij aan werkt via zijn tak.

Om de gebruikers aan te spreken die de titel van de vraag lezen, de eigenlijke inhoud en context van de vraag overslaan, en dan alleen het bovenste antwoord blindelings lezen, ervan uitgaande dat het altijd van toepassing is op hun (andere) gebruiksgeval, sta me toe het uit te leggen:

• Rebase privétakken (d.w.z. die alleen in uw lokale repository bestaat en niet met anderen zijn gedeeld). Rebasing Gedeelde takken zou “breken” de exemplaren die andere mensen hebben.
• Als u veranderingen van een filiaal wilt integreren (of het nu gaat om de meester of een andere tak) in een tak die openbaar is (bijvoorbeeld dat u de tak hebt geduwd om een ​​pull-aanvraag te openen, maar er zijn nu conflicten met Master en u nu Noodzaak om uw filiaal bij te werken om die conflicten op te lossen) Moet u ze samenvoegen (bijv. Met git merge masterzoals in @ Sven’s antwoord).
• U kunt takken ook samenvoegen in uw lokale privétakken, indien dat uw voorkeur is, maar houd er rekening mee dat het zal resulteren in “buitenlandse” commits in uw tak.

Eindelijk, als je niet tevreden bent met het feit dat dit antwoord niet de beste pasvorm is voor je situatie, ook al was het voor @theomega, het toevoegen van een opmerking hieronder zal niet bijzonder behulpzaam zijn: ik heb geen controle over welk antwoord niet is geselecteerd, alleen @theomega doet.

Antwoord 3, Autoriteit 5%

Gebaseerd op dit artikel , moet u:

• Maak een nieuwe tak die is gebaseerd op nieuwe versie van MASTER

  git branch -b newmaster

• Voeg uw oude functie-tak samen in nieuwe

  git checkout newmaster

• Conflicten op het gebied van nieuwe functie

De eerste twee opdrachten kunnen worden gecombineerd met git checkout -b newmaster.

Op deze manier blijft uw geschiedenis duidelijk omdat u niet terugvoegt. En je hoeft niet zo super voorzichtig te zijn, omdat je geen git-rebase hoeft te doen.

Antwoord 4, Autoriteit 5%

git merge

U kunt onderstaande stappen volgen

1. merge origin/masterbranch met featurebranch

# step1: change branch to master, and pull to update all commits
$ git checkout master
$ git pull
# step2: change branch to target, and pull to update commits
$ git checkout feature
$ git pull
# step3: merge master to feature(⚠️ current is feature branch)
$ git merge master

2. voeg featurebranch samen met origin/masterbranch

origin/masteris de externe master-branch, terwijl masterde lokale master-branch is

$ git checkout master
$ git pull origin/master
$ git merge feature
$ git push origin/master

Antwoord 5, autoriteit 2%

Zimi’s antwoordbeschrijft dit proces in het algemeen. Dit zijn de details:

1. Maak en schakel over naar een nieuwe vertakking. Zorg ervoor dat de nieuwe branch gebaseerd is op masterzodat deze de recente hotfixes bevat.

   git checkout master
   git branch feature1_new
   git checkout feature1_new
   # Or, combined into one command:
   git checkout -b feature1_new master
   

2. Na het overschakelen naar de nieuwe branch, voeg je de wijzigingen van je bestaande feature branch samen. Dit zal je commits toevoegen zonder de hotfix commits te dupliceren.

   git merge feature1
   

3. Los in de nieuwe branch eventuele conflicten tussen uw feature en de master branch op.

Klaar! Gebruik nu de nieuwe branch om je feature verder te ontwikkelen.

Antwoord 6

Hier is een script dat je kunt gebruiken om je master branch samen te voegen met je huidige branch.

Het script doet het volgende:

• Schakelt over naar de master branch
• Trekt de master branch
• Schakel terug naar uw huidige filiaal
• Samenvoegt de master branch in je huidige branch

Sla deze code op als een batchbestand (.bat) en plaats het script ergens in uw repository. Klik er dan op om het uit te voeren en je bent klaar.

:: This batch file pulls current master and merges into current branch
@echo off
:: Option to use the batch file outside the repo and pass the repo path as an arg
set repoPath=%1
cd %repoPath%
FOR /F "tokens=*" %%g IN ('git rev-parse --abbrev-ref HEAD') do (SET currentBranch=%%g)
echo current branch is %currentBranch%
echo switching to master
git checkout master
echo.
echo pulling origin master
git pull origin master
echo.
echo switching back to %currentBranch%
git checkout %currentBranch%
echo.
echo attemting merge master into %currentBranch%
git merge master
echo.
echo script finished successfully
PAUSE

Antwoord 7

Ik voeg mijn antwoord toe, vergelijkbaar met dat van anderen, maar misschien is het de snelste om te lezen en uit te voeren.

OPMERKING: Rebase is in dit geval niet nodig.

Stel dat ik een repo1en twee branches masteren dev-userheb.

dev-useris een branch die wordt gedaan met een bepaalde status van master.

Veronderstel nu dat zowel dev-userals masterverder gaan.

Op een gegeven moment wil ik dat dev-useralle commits krijgt die zijn gemaakt in master.

Hoe doe ik het?

Ik ga eerst naar de hoofdmap van mijn repository

cd name_of_the_repository

dan

git checkout master 
git pull 
git checkout dev-user
git pull
git merge master 
git push 

Ik hoop dat dit iemand anders in dezelfde situatie helpt.

Antwoord 8

Mogelijk kunt u een “cherry-pick” doen om de exact commit (s) te trekken die u nodig hebt bij uw functie Branch.

Doe een git checkout hotfix1om op de hotfix1-tak te komen. Doe dan een git logom de SHA-1 HASH (grote reeks willekeurige letters en cijfers te krijgen die uniek een commit te identificeren) van de betreffende commit. Kopieer dat (of de eerste 10 of zo tekens).

Dan, git checkout feature1om terug te gaan naar uw functie Branch.

Dan, git cherry-pick <the SHA-1 hash that you just copied>

Dat trekt die commit en alleen die zich in uw functie vertonen. Die verandering zal in de tak zijn – je hebt het gewoon ‘kersen geplukt’. Dan hervatten werk, bewerken, commit, push, etc. naar de inhoud van je hart.

Wanneer u uiteindelijk een andere samenvoeging van de ene tak (of vice-versa) uitvoert, zal Git erkennen dat u al in die specifieke begaan, weet dat het niet is moet het opnieuw opnieuw maken en gewoon “overslaan”.

Antwoord 9

Vul de bestaande antwoorden aan, aangezien deze opdrachten terugkerend zijn, kunnen we het op een rij doen. Gegeven we zitten in de functie Branch:

git checkout master && git pull && git checkout - && git merge -

of voeg ze toe in een alias:

alias merge_with_master="git checkout master && git pull && git checkout - && git merge -"

Antwoord 10

Ik ben op de feature-tak en maakte refactorings. Ik wil de master nu samenvoegen aan mijn functie-tak. Ik ben ver achter. Opmerking Ik wil niet de meesterwijzigingen in mijn lokale gebruiken omdat mijn functie-filiaal modules van de ene plaats naar de andere is bewogen. Ik vond dat ik gewoon onderdrukt zonder pull werkt niet. Er staat “al up-to-date”.

//below does not get the latest from remote master to my local feature branch without git pull
    git checkout master 
    git fetch 
    git checkout my-feature-branch 
    git merge master

Hieronder werken, OPMERKING Gebruik Git Merge Origin / Master:

git checkout master 
    git fetch 
    git checkout my-feature-branch 
    git merge origin/master

Antwoord 11

Om grote bestanden te starten, hoeft u alleen deze eenvoudige stappen te volgen:
Download en installeer en installeer de Extensions van GIT LFS-opdrachtregel voor uw besturingssysteem.
Setup Git LFS voor uw gebruikersaccount:
git lfs installeren
3. Configureer GIT LFS om uw grote bestanden bij te houden:
Git LFS TRACK “* .XYZ”

Antwoord 12

In Eclipse -

1) Checkout Master Branch

Git Repositories ->Click on your repository -> click on Local ->double click master branch
->Click on yes for check out

2) Trek de mastertak

Right click on project ->click on Team -> Click on Pull

3) Afrekenen Uw functie Branch (volg dezelfde stappen die in 1 punt worden genoemd)

4) Master samenvoegen in functie

Git Repositories ->Click on your repository -> click on Local ->Right Click on your selected feature branch ->Click on merge ->Click on Local ->Click on Master ->Click on Merge.

5) Nu krijgt u alle wijzigingen in de mastertak in Feature Branch. Verwijder conflict indien aanwezig.

For conflict if any exists ,follow this -
Changes mentioned as Head(<<<<<< HEAD) is your change, Changes mentioned in branch(>>>>>>> branch) is other person change, you can update file accordingly.

OPMERKING – U moet toevoegen aan index voor conflictenbestanden

6) Begin en druk op uw wijzigingen in de functie Branch.

Right click on project ->click on Team -> Click on commit -> Commit and Push.

of

Git Repositories ->Click on your repository -> click on Local ->Right Click on your selected feature branch ->Click on Push Branch ->Preview ->Push