Care este cel mai bun (și cel mai sigur) mod de a îmbina o ramură Git în master?

Cum aș face asta

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

Dacă am o sucursală locală de la una la distanță, nu mă simt confortabil să comas alte ramuri decât aceasta cu telecomandă. De asemenea, nu mi-aș împinge modificările, până când nu sunt mulțumit de ceea ce vreau să împing și, de asemenea, nu aș împinge deloc lucrurile, care sunt doar pentru mine și pentru depozitul meu local. În descrierea ta se pare că test este doar pentru tine? Deci nu există niciun motiv să-l public.

git încearcă întotdeauna să respecte schimbările tale și ale altora, la fel și --rebase. Nu cred că pot explica în mod corespunzător, așa că aruncați o privire la cartea Git - Rebazare sau git-ready: Introducere în rebazare pentru o mică descriere. Este o caracteristică destul de cool

Aceasta este o întrebare foarte practică, dar toate răspunsurile de mai sus nu sunt practice.

Ca

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

Această abordare are două probleme:

1. Este nesigur, deoarece nu știm dacă există conflicte între ramura de testare și ramura principală.

2. Ar „strânge” toate comiterile de testare într-un singur comit de îmbinare pe master; adică pe ramura principală, nu putem vedea toate jurnalele de modificări ale ramurii de testare.

Deci, atunci când bănuim că ar exista unele conflicte, putem avea următoarele operații git:

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

Testați merge înainte de commit, evitați o comitere rapidă înainte de --no-ff,

Dacă se întâlnește un conflict, putem rula git status pentru a verifica detaliile despre conflicte și a încerca să le rezolvăm

git status

Odată ce rezolvăm conflictele, sau dacă nu există conflict, le commit și push

git commit -m 'merge test branch'
git push

Dar în acest fel se va pierde istoricul modificărilor înregistrate în ramura de testare și ar face ca ramura principală să fie dificilă pentru alți dezvoltatori să înțeleagă istoria proiectului.

Deci, cea mai bună metodă este să folosim rebase în loc de merge (să presupunem că, în acest timp, am rezolvat conflictele de ramuri).

Mai jos este un exemplu simplu, pentru operațiuni avansate, vă rugăm să consultați 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

Da, când ai terminat upper, toate commit-urile ramului Test vor fi mutate în șeful ramului Master. Beneficiul major al rebazării este că obțineți un istoric al proiectului liniar și mult mai curat.

Singurul lucru pe care trebuie să-l evitați este: nu utilizați niciodată rebase pe ramura publică, cum ar fi ramura principală.

Nu efectuați niciodată operațiuni precum următoarele:

git checkout master
git rebase -i test

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

apendice:

• dacă nu sunteți sigur despre operațiunile de rebazare, vă rugăm să consultați: https://git-scm.com/book/en/v2/Git-Branching-Rebasing

Nici o rebazare, nici o îmbinare nu ar trebui să suprascrie modificările nimănui (cu excepția cazului în care alegeți să faceți acest lucru atunci când rezolvați un conflict).

Abordarea obișnuită în timpul dezvoltării este

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

Când ești gata să fuzionezi din nou în master,

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

Dacă sunteți îngrijorat că nu veți sparge ceva la îmbinare, git merge --abort este acolo pentru dvs.

Este o prostie să folosești împingerea și apoi tragerea ca mijloc de îmbinare. De asemenea, nu sunt sigur de ce împingeți testul la origine.

Mai întâi aș face ramura care urmează să fie îmbinată cât mai curată posibil. Rulați-vă testele, asigurați-vă că starea este așa cum doriți. Curățați noile comenzi prin git squash.

Pe lângă Răspunsul KingCrunches, vă sugerez să utilizați

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

S-ar putea să fi făcut multe comiteri în cealaltă ramură, care ar trebui să fie doar un comit în ramura principală. Pentru a menține istoricul de comitere cât mai curat posibil, s-ar putea să doriți să strângeți toate comitările din ramura de testare într-un singur comit în ramura principală (consultați și: Git: To squash or not to squash?). Apoi, puteți și rescrie mesajul de confirmare la ceva foarte expresiv. Ceva care este ușor de citit și de înțeles, fără să pătrundă în cod.

edit: S-ar putea să te intereseze

• În git, care este diferența dintre merge --squash și rebase?
• Imbinare vs. rebazare
• Cum să rebazați o solicitare de tragere

Deci, pe GitHub, ajung să fac următoarele pentru o ramură de caracteristică mybranch:

Obțineți cele mai recente de la origine

$ git checkout master
$ git pull origin master

Găsiți hashul de bază de îmbinare:

$ git merge-base mybranch master
c193ea5e11f5699ae1f58b5b7029d1097395196f

$ git checkout mybranch
$ git rebase -i c193ea5e11f5699ae1f58b5b7029d1097395196f

Acum asigurați-vă că numai primul este pick, restul este s:

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

Apoi alegeți un mesaj de confirmare foarte bun și apăsați în GitHub. Atunci faceți cererea de tragere.

După îmbinarea cererii de extragere, o puteți șterge local:

$ git branch -d mybranch

și pe GitHub

$ git push origin :mybranch

Subiect vechi, dar nu am găsit modul meu de a o face. Ar putea fi valoros pentru cineva care lucrează cu rebase și dorește să îmbine toate commit-urile dintr-o ramură (funcție) deasupra masterului. Dacă există un conflict pe drum, le puteți rezolva pentru fiecare comitere. Păstrați controlul deplin în timpul procesului și puteți anula oricând.

Aflați la curent cu Master și Filială:

git checkout master
git pull --rebase origin master
git checkout <branch_name>
git pull --rebase origin <branch_name>

Îmbinați sucursala peste Master:

git checkout <branch_name>
git rebase master

Opțional: dacă întâmpinați conflicte în timpul rebazei:

În primul rând, rezolvați conflictul în dosar. Apoi:

git add .
git rebase --continue

Puteți anula rebazarea oricând cu:

git rebase --abort

Impingeți-vă Sucursala rebazată:

git push origin <branch_name>

Dacă aveți această ramură împinsă înainte, trebuie să o depășiți cu o împingere forțată:

git push origin -f <branch_name>

Înainte de a face acest lucru, verificați întotdeauna dacă filiala dvs. locală actuală corespunde așteptărilor dvs., deoarece forțarea o înlocuiește pe cea veche din depozitul de la distanță.

Acum aveți două opțiuni:

• A) Creați un PR (de exemplu, pe GitHub) și îmbinați-l acolo prin interfața de utilizare
• B) Reveniți pe linia de comandă și îmbinați ramura în master

git checkout master
git merge --no-ff <branch_name>
git push origin master

Terminat.

Acesta este fluxul de lucru pe care îl folosesc la locul meu de muncă cu echipa. Scenariul este așa cum ați descris. În primul rând, când am terminat de lucrat la test, rebazez cu master pentru a extrage orice a fost adăugat la master în timpul cât am lucrat la ramura test.

git pull -r upstream master

Acest lucru va trage modificările la master de când ați bifurcat ramura test și le va aplica, apoi va aplica modificările pe care le-ați făcut pentru a testa „pe deasupra” stării curente a masterului. Pot exista conflicte aici, dacă celelalte persoane au făcut modificări la aceleași fișiere pe care le-ați editat în test. Dacă există, va trebui să le remediați manual și să le efectuați. Odată ce ați făcut asta, veți fi bine să treceți la ramura principală și să îmbinați test fără probleme.

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

După îmbinare, dacă fișierul este modificat, atunci când îmbinați, acesta va apărea printr-o eroare de „Rezolvare conflict”

Deci, mai întâi trebuie să-ți rezolvi toate conflictele, apoi trebuie să comiți din nou toate modificările și apoi să împingi

git push origin master

Este mai bine să facă cine a făcut modificări în ramura de testare, pentru că știa ce modificări a făcut.

Aș folosi metoda rebase. Mai ales pentru că reflectă perfect cazul tău din punct de vedere semantic, de exemplu. ceea ce doriți să faceți este să reîmprospătați starea ramurii dvs. actuale și să vă „prefaceți” ca și cum s-ar fi bazat pe cea mai recentă.

Deci, fără măcar să verific master, aș:

git fetch origin
git rebase -i origin/master
# ...solve possible conflicts here

Desigur, doar preluarea de la origine nu reîmprospătează starea locală a master-ului dvs. (deoarece nu efectuează o îmbinare), dar este perfect ok pentru scopul nostru - vrem să evităm schimbarea, de dragul economisirii de timp.

Răspunsul lui @KingCrunch ar trebui să funcționeze în multe cazuri. O problemă care poate apărea este că este posibil să vă aflați pe o altă mașină care trebuie să extragă cele mai recente din test. Așadar, recomand să faci testul de tragere mai întâi. Revizia arată astfel:

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

Voi răspunde conform ramurilor de dezvoltare și caracteristică,

dacă sunteți în ramura de caracteristici și trebuie să o actualizați cu develop, utilizați comenzile de mai jos:

git checkout develop
git pull
git checkout feature/xyz
git merge develop

Acum feature/xyz este actualizat cu ramura develop și vă puteți împinge modificările la feature/xyz de la distanță.

După cum spune titlul „Cel mai bun mod”, cred că este o idee bună să luați în considerare strategia de îmbinare a răbdare.

De la: https://git-scm.com/docs/merge-strategies

Cu această opțiune, „merge-recursive” petrece puțin timp în plus pentru a evita îmbinările greșite care apar uneori din cauza liniilor de potrivire neimportante (de exemplu, acolade de la funcții distincte). Folosiți-l atunci când ramurile care urmează să fie îmbinate s-au divergent în mod sălbatic. Vezi și git-diff[1] --patience.

Utilizare:

git fetch
git merge -s recursive -X patience origin/master

Git Alias

Folosesc întotdeauna un alias pentru asta, de ex. alerga o data:

 git config --global alias.pmerge 'merge -s recursive -X patience'

Acum ai putea face:

git fetch
git pmerge origin/master

Trebuie să verificați ramura pentru a trage, deoarece tragerea înseamnă fuzionarea în master și aveți nevoie de un arbore de lucru pentru a se îmbina.

git checkout master
git pull

Nu este nevoie să verificați mai întâi; rebase face ceea ce trebuie cu două argumente

git rebase master test  

git checkout master
git merge test

git push împinge în mod implicit toate ramurile care există aici și pe telecomandă

git push
git checkout test

Acesta este de la GitLab: trebuie doar să urmați instrucțiunile:

Primesc întotdeauna conflicte de îmbinare când fac doar git merge feature-branch. Acest lucru pare să funcționeze pentru mine:

git checkout -b feature-branch

Faceți o grămadă de modificări de cod...

git merge -s ours master 

git checkout master

git merge feature-branch

or

git checkout -b feature-branch

Faceți o grămadă de modificări de cod...

git checkout master

git merge -X theirs feature-branch