Cum pot rezolva fuziona conflicte in Git?
Încercați: git mergetool
Se deschide un GUI pe care le pașii prin fiecare conflict, și veți obține pentru a alege modul de a fuziona. Uneori este nevoie de un pic de editare manual după aceea, dar, de obicei's suficient de la sine. Este mult mai bine decât a face totul cu mâna, cu siguranță.
Ca pe @JoshGlover comentariu:
Comanda nu't neapărat de a deschide un GUI dacă instalați unul. Rularea git mergetool pentru mine a dus în
vimdiffa fi folosit. Puteți instala unul din următoarele instrumente pentru a utiliza în loc de:
unire,
opendiff,
kdiff3,
tkdiff,
xxdiff,
tortoisemerge,
gvimdiff,
difuz,
ecmerge,
p4merge,
araxis,
vimdiff,
apar`.
Mai jos este o mostră de procedură pentru a utiliza `vimdiff pentru a rezolva fuziona conflicte. Bazat pe acest link
Etapa 1: Rulați următoarele comenzi în terminal
git config merge.tool vimdiff
git config merge.conflictstyle diff3
git config mergetool.prompt false
Acest lucru va stabili vimdiff ca implicit instrument de îmbinare.
Pasul 2: Executați următoarea comandă în terminal
git mergetool
Pasul 3: Veți vedea un vimdiff afișa în următorul format
╔═══════╦══════╦════════╗
║ ║ ║ ║
║ LOCAL ║ BASE ║ REMOTE ║
║ ║ ║ ║
╠═══════╩══════╩════════╣
║ ║
║ MERGED ║
║ ║
╚═══════════════════════╝
Aceste 4 puncte de vedere sunt
LOCAL – acest fișier este de ramura curentă
de BAZĂ – strămoș comun, cum arăta înainte, atât modificări
la DISTANȚĂ – fișierul pe care fuzionează într-filiala
UNIRE – unificare urmare, aceasta este ceea ce devine salvate în repo
Puteți naviga printre aceste puncte de vedere, folosind ctrl+w. Puteți ajunge direct FUZIONAT vedere folosind ctrl+w urmat de j.
Mai multe informatii despre vimdiff de navigare aici și aici
Pasul 4. Ai putea edita FUZIONAT vedere felul următor
Dacă doriți pentru a obține modificări de la DISTANȚĂ
:diffg RE
Dacă doriți pentru a obține modificări de BAZĂ
:diffg BA
Dacă doriți să obțineți modificările de la nivel LOCAL
:diffg LO
Pasul 5. Salva, de Ieșire, a Comis-o și Curat
:pca
salva si a iesi din vi
git commit -m "mesaj"
`git curat pentru a Elimina fișiere suplimentare (de exemplu *.orig) create de dif instrument.
Aici's un posibil caz de utilizare, de sus:
Te're de gând pentru a trage unele modificări, dar oops, ai're nu până la data de:
git fetch origin
git pull origin master
From ssh://[email protected]:22/projectname
* branch master -> FETCH_HEAD
Updating a030c3a..ee25213
error: Entry 'filename.c' not uptodate. Cannot merge.
Așa că ridică-te-la-data și încercați din nou, dar avea un conflict:
git add filename.c
git commit -m "made some wild and crazy changes"
git pull origin master
From ssh://[email protected]:22/projectname
* branch master -> FETCH_HEAD
Auto-merging filename.c
CONFLICT (content): Merge conflict in filename.c
Automatic merge failed; fix conflicts and then commit the result.
Deci, vă decideți să ia o privire la modificările:
git mergetool
Oh my, Oh my, în amonte schimbat unele lucruri, dar doar pentru a-mi folosesc schimbări...nu...lor se schimbă...
git checkout --ours filename.c
git checkout --theirs filename.c
git add filename.c
git commit -m "using theirs"
Și apoi vom încerca o dată finală
git pull origin master
From ssh://[email protected]:22/projectname
* branch master -> FETCH_HEAD
Already up-to-date.
Ta-da!
Am găsit merge instrumente rareori ajută-mă să înțeleg conflictul sau rezoluția. Am'm, de obicei mai mult succes în căutarea la conflictul markeri într-un editor de text și folosind git log ca un supliment.
Aici sunt câteva sfaturi:
Cel mai bun lucru pe care l-am găsit este de a utiliza "diff3" îmbinare stil de conflict:
git config fuziona.conflictstyle diff3
Aceasta produce conflict markeri astfel:
<<<<<<<
Changes made on the branch that is being merged into. In most cases,
this is the branch that I have currently checked out (i.e. HEAD).
|||||||
The common ancestor version.
=======
Changes made on the branch that is being merged in. This is often a
feature/topic branch.
>>>>>>>
Secțiunea de mijloc este ceea ce strămoș comun arata ca. Acest lucru este util pentru că puteți compara-l la partea de sus și de jos versiuni pentru a obține un mai bun simț de ce a fost schimbat de pe fiecare ramură, care vă oferă o mai bună idee pentru ce scop are fiecare schimbare a fost.
În cazul în care conflictul este de numai câteva rânduri, în general, acest lucru face ca acest conflict foarte evident. (A ști cum să rezolvi un conflict este foarte diferit; trebuie să fie conștienți de ceea ce alți oameni sunt de lucru pe. Daca're confuz, l's, probabil, mai bine să spunem că persoana în camera dvs., astfel încât ei pot vedea ceea ce ai're în căutarea la.)
Dacă conflictul este mai mult, atunci I se va tăia și lipi fiecare dintre cele trei secțiuni în trei fișiere separate, cum ar fi "a mea", "comun" și "a lor".
Atunci pot să rulați următoarele comenzi pentru a vedea cele două dif zgârcit care a cauzat conflictul:
diff common mine
diff common theirs
Acest lucru nu este la fel ca folosind un instrument de îmbinare, deoarece un instrument de îmbinare va include toate non-contradictorii dif prea zgârcit. Cred că distrag atenția.
Cineva a menționat deja acest lucru, dar înțelegerea intenția din spatele fiecare dif bucată este, în general, foarte utile pentru înțelegerea în cazul în care un conflict venit de la și cum să-l ocupe.
git log --merge -p <name of file>
Acest lucru arată toate se angajează că a atins acel fișier în între strămoș comun și cei doi șefi ai fuzionează. (Deci, nu't includă se angajează că deja există în ambele ramuri înainte de fuziune.) Acest lucru vă ajută să ignore dif zgârcit, care în mod clar nu sunt un factor în actualul conflict.
Verifica modificările cu instrumente automatizate.
Dacă aveți teste automate, fugi. Dacă aveți o scame, executați asta. Daca's o construibil proiect, apoi construi înainte de a vă angaja, etc. În toate cazurile, aveți nevoie pentru a face un pic de testare pentru a vă asigura că modificările nu't rupe nimic. (La naiba, chiar o îmbinare fără conflicte pot sparge codul de lucru.)
Planifica; a comunica cu co-lucrătorilor.
Înainte de planificare și de a fi conștienți de ceea ce alții sunt de lucru pe poate ajuta la prevenirea merge conflicte și/sau de a ajuta a le rezolva mai devreme-în timp ce detaliile sunt încă proaspete în minte.
De exemplu, dacă știi că ai și o altă persoană sunt atât de lucru pe diferite refactoring, care va afecta același set de fișiere, ar trebui să vorbesc cu fiecare alte înainte de timp și a obține un sentiment mai bun pentru ce tipuri de modificări fiecare dintre voi este de a face. S-ar putea economisi timp și efort considerabil dacă ați efectua modificările planificate în serie, mai degrabă decât în paralel.
Pentru refactoriz arile majore care parcurg o serie mare de cod, tu ar trebui să ia în considerare puternic de lucru în serie: toată lumea se oprește de lucru pe zona de cod, în timp ce o persoană îndeplinește complet de refactorizare.
Dacă poți't de lucru în serie (din cauza presiunii timpului, poate), atunci comunicarea despre temperatura fuziona conflicte, cel puțin vă ajută să rezolvați problemele mai devreme, în timp ce detaliile sunt încă proaspete în minte. De exemplu, dacă un co-lucrător este de a face un perturbator serie de comite de-a lungul unei săptămâni, puteți alege să fuzioneze/rebazare pe care co-lucrătorilor ramura dată sau de două ori în fiecare zi din timpul săptămânii. Așa, dacă faci găsi fuziona/rebazare conflicte, nu le poate rezolva mult mai repede decât dacă vă așteptați câteva săptămâni pentru a merge totul împreună într-o singură bucată mare.
Daca're sigur de o unificare, don't forța.
Fuziunea poate simți copleșitoare, mai ales atunci când există o mulțime de conflict de fișiere și conflictul markeri acoperi sute de linii. De multe ori, atunci când software-ul de estimare a proiectelor noi nu't include suficient timp pentru regie elemente, cum ar fi manipularea unui noduros merge, asa ca se simte ca un adevărat drag pentru a petrece câteva ore de disecție fiecare conflict.
Pe termen lung, planificare și fiind conștienți de ceea ce alții sunt de lucru pe sunt cele mai bune instrumente pentru anticiparea merge conflicte și pregătiți-vă pentru a le rezolva corect în mai puțin timp.
Identifica fișierele care sunt în conflict (Git ar trebui să-ți spun asta).
Deschide fiecare fișier și de a examina diff; Git delimitează de ei. Să sperăm că acesta va fi evident ce versiune de fiecare bloc pentru a menține. Posibil să aveți nevoie pentru a discuta cu colegii dezvoltatori care au comis cod.
Odată ce ai'am rezolvat conflictul într-un fișier git add the_file
.
Odată ce ai'am rezolvat toate conflictele, nu git rebazare-continua
sau orice comandă
Git spus să fac atunci când ați terminat.
Verificați răspunsurile la Stack Overflow întrebare Avorta un fuziona in Git, mai ales Charles Bailey's a răspunde, care arată cum pentru a vizualiza diferitele versiuni ale fișierului cu probleme, de exemplu,
# Common base version of the file.
git show :1:some_file.cpp
# 'Ours' version of the file.
git show :2:some_file.cpp
# 'Theirs' version of the file.
git show :3:some_file.cpp
Merge conflicte se întâmplă când se efectuează modificări într-un fișier în același timp. Aici este cum să-l rezolve.
git
CLIAici sunt pași simpli ce să faci atunci când vei ajunge în conflict de stat:
git status
(sub `Unmerged căi de secțiune).Utilizați GUI pentru a rezolva conflictele: git mergetool
(cel mai simplu mod).
Să accepte de la distanță/alte versiuni, utilizați: git checkout-a lor cale/fișier
. Acest lucru va respinge orice modificări locale ai făcut pentru acel fișier.
Să accepte locale/versiunea noastră, utilizați: git checkout-a noastra cale/fișier
cu toate Acestea nu'am să fi atent, ca și de la distanță modificări care conflictele s-au făcut pentru un motiv oarecare.
Legate de: https://stackoverflow.com/q/25576415/55075
Editați conflict de fișierele manual si uita-te pentru codul bloc între <<<<<
/>>>>>
apoi alege varianta fie de sus sau de jos =====
. A se vedea: Modul în care conflictele sunt prezentate.
Calea și numele de fișier conflicte pot fi rezolvate prin git add
/git rm
.
git status
.Dacă aveți în continuare fișiere sub Unmerged căi
, și-ai făcut rezolva conflictul manual, apoi să Git știu că ați rezolvat-o prin: git add cale/fișier
.
Vezi de asemenea și: Rezolvarea o îmbinare de conflict din linia de comanda la GitHub
Pentru tutorial practice, verificați: Scenariul 5 - Fixarea Merge Conflicte de Katacoda.
Am'am folosit cu succes DiffMerge, care se poate compara vizual și uni fișiere de pe Windows, macOS și Linux/Unix.
Grafic poate arăta modificări între 3 fișiere și vă permite fuzionarea automată (atunci când este sigur să facă acest lucru) și control deplin asupra editarea fișierului rezultat.
sursa Imaginii: DiffMerge (Linux screenshot)
Pur și simplu descărca și rula în repo fi:
git mergetool -t diffmerge .
Pe macOS puteți instala prin:
brew install caskroom/cask/brew-cask
brew cask install diffmerge
Și probabil (dacă nu este furnizat) ai nevoie de urmatoarele înveliș simplu plasate în CALEA ta (de exemplu /usr/bin
):
#!/bin/sh
DIFFMERGE_PATH=/Applications/DiffMerge.app
DIFFMERGE_EXE=${DIFFMERGE_PATH}/Contents/MacOS/DiffMerge
exec ${DIFFMERGE_EXE} --nosplash "$@"
Apoi, aveți posibilitatea să utilizați următoarele comenzi rapide de la tastatură:
Alternativ, puteți utiliza opendiff (partea de Xcode Instrumente), care vă permite să fuzioneze două fișiere sau directoare împreună pentru a crea un al treilea fișier sau director.
Daca're face frecvente mici se angajează, atunci începe prin a te uita la comiterea comentarii cu git log --îmbinare
. Apoi git diff
va arăta conflicte.
Pentru conflictele care implică mai mult de câteva rânduri, l's ușor pentru a vedea ce's-a întâmplat într-un externă instrument de GUI. Îmi place opendiff -- Git, de asemenea, sprijină vimdiff, gvimdiff, kdiff3, tkdiff, meld, xxdiff, ieși din cutie și îl puteți instala altele: git config fuziona.tool "ta.tool"
va stabili datele alese de instrument și atunci git mergetool
după ce nu a reușit o îmbinare va arăta diff în context.
De fiecare dată când editați un fișier pentru a rezolva un conflict, git add filename
va actualiza indexul si dif nu va mai arăta. Când toate sunt gestionate conflictele și fișierele lor au fost git add
-ed, git commit
va finaliza fuziona.
Consultați Modul în care Conflictele Sunt Presented sau, în Git, la `git merge de documentare pentru a înțelege ceea ce merge conflict markeri sunt.
De asemenea, Cum pentru a Rezolva Conflictele secțiune explică modul de rezolvare a conflictelor:
După ce a văzut un conflict, puteți face două lucruri:
- Decide să nu fuzioneze. Singurul curat-up-uri ai nevoie pentru a reseta fișier index pentru " ȘEF " se angajează să reverse 2. și pentru a curăța de lucru arbore de modificările făcute de 2. și 3.;
git merge --abandonați
poate fi folosit pentru acest lucru.
- Rezolvarea conflictelor. Git va marca conflicte în arborele de lucru. Editați fișierele în formă și
git add
i la index. Folosesc git commit` pentru a sigila afacere.
puteți lucra prin conflict cu o serie de instrumente:
- Utilizați un mergetool.
git mergetool
pentru a lansa un grafic mergetool care va lucra prin îmbinare.
- Uita-te la diff.
git diff
va arăta o modalitate de trei dif, evidențiind modificările de la ambele CAP " și " MERGE_HEAD` versiuni.
- Uita-te la diff din fiecare ramură.
git log --îmbinare -p <calea>
va arăta diff prima pentru " ȘEF " versiune și apoiMERGE_HEAD
versiune.
- Uita-te la cele originale.
git show :1:filename
arată strămoș comun,git show :2:fisier spectacole de " ȘEF " versiune, și
git show :3:filenamearată
MERGE_HEAD` versiune.
De asemenea, puteți citi despre fuziona conflict markeri și cum să le rezolve în Pro Git secțiune de carte de Bază Fuziona Conflicte.
Pentru Emacs utilizatori care doresc pentru a rezolva fuziona conflicte semi-manual:
git diff --name-status --diff-filter=U
afișează toate fișierele care necesită soluționare a conflictelor.
Deschide fiecare dintre aceste fișiere unul câte unul, sau toate la o dată de:
emacs $(git diff --name-only --diff-filter=U)
Atunci când vizitează un tampon care necesită modificări în Emacs, tip
ALT+x vc-resolve-conflicts
Aceasta va deschide trei tampoane (a mea, a lor, și tampon de ieșire). Navigați prin apăsarea 'n' (regiune), 'p' (previziune regiune). Apăsați 'un' si 'b' pentru a copia mea sau a lor regiune tampon de ieșire, respectiv. Și/sau edita tampon de ieșire direct.
Când ați terminat: Apăsați 'q'. Emacs-ul te întreabă dacă doriți să salvați acest buffer: da. După ce a terminat un tampon marca ca rezolvat prin rularea din teriminal:
git add FILENAME
Când ați terminat cu toate tampoanele de tip
git commit
pentru a termina îmbinarea.
Fie vreau mele sau versiunea lor în întregime, sau doriți să revizuiască modificări individuale și să decidă pentru fiecare dintre ele.
Accepta pe deplin mea sau a lor versiune:
Acceptă versiunea mea (locale, al nostru):
git checkout --ours -- <filename>
git add <filename> # Marks conflict as resolved
git commit -m "merged bla bla" # An "empty" commit
Acceptă versiunea lor (de la distanță, a lor):
git checkout --theirs -- <filename>
git add <filename>
git commit -m "merged bla bla"
Dacă vrei să faci pentru toate conflictului fișiere run:
git merge --strategy-option ours
sau
git merge --strategy-option theirs
Revizuirea toate modificările și a le accepta în mod individual
git mergetool
git add <nume>
git commit -m "fuzionat bla bla"
Default mergetool
funcționează în în linia de comandă. Cum să utilizați o linie de comandă mergetool ar trebui să fie o întrebare separată.
Puteți instala, de asemenea, instrument vizual pentru acest lucru, de exemplu, unire
și a alerga
git mergetool -t meld
Se va deschide versiunea locală (al nostru), "baza" sau "fuzionat" versiune (rezultatul curent a merge) și versiunea de la distanță (lor). Salvați versiunea combinată atunci când ați terminat, executați git mergetool -t amestec
din nou până când veți obține "fișierele Nu au nevoie de unirea", apoi du-te la Pașii 3. și 4.
Pur și simplu, dacă știi bine că schimbă într-una din magaziile nu este important, și doriți pentru a rezolva toate modificările în favoarea celuilalt, utilizați:
git checkout . --ours
pentru a rezolva modificări în favoarea depozit, sau
git checkout . --theirs
pentru a rezolva modificări în favoarea sau alte principalul depozit.
Sau altfel va trebui să utilizați un GUI instrument de îmbinare la pas prin fișierele unul câte unul, spun instrument de îmbinare este p4merge
, sau scrie orice o's nume'am deja instalat
git mergetool -t p4merge
și după ce a terminat un fișier, va trebui să salvați și închideți, deci, următoarea va deschide.
Vă rugăm să urmați următorii pași pentru a repara erorile de îmbinare conflicte in Git:
Verificați starea Git: git status
Obține patchset: git fetch (checkout dreptul de patch-uri de pe Git commit)
Plateste o filială locală (temp1 în exemplul meu): git checkout -b temp1
Trage recente conținutul de master: git pull --rebazare origine master
Începe mergetool și verificați conflicte și de a le repara...și verificați modificările la distanță ramură cu ramură de curent: git mergetool
Verificați starea din nou: git status
Șterge fișierele nedorite la nivel local creat de mergetool, de obicei mergetool creează fișier suplimentar cu *.orig extensie. Vă rugăm să ștergeți acest fișier ca asta este doar duplicat și repara erorile de schimbări la nivel local și se adaugă versiunea corectă a fișierelor. git add #your_changed_correct_files
Verificați starea din nou: git status
Comite modificările la același comite un act de identitate (astfel se evită o nouă separate patch set): git a comis-o ... amend
Apasă ramura de master: git push (la Git repository)
Vorbind de tragere/aduce/fuziona in raspunsurile de mai sus, aș dori să vă împărtășesc un interesant și productiv truc,
git pull --rebazare
Aceasta comanda de mai sus este cea mai utilă comandă în git viață care a salvat o mulțime de timp.
Înainte de a împinge nou angajat schimba la server de la distanță, încercați să git pull --rebazare
destul git pull
și manuală merge
si se va sincroniza automat cele mai recente server de la distanță modificări (cu o aduce + îmbinare) și va pune locale mai recente comite în partea de sus în git log. Nu este nevoie să vă faceți griji despre manual trage/merge.
În caz de conflict, trebuie doar să utilizați
git mergetool
git add conflict_file
git rebase --continue
Găsiți detalii la: http://gitolite.com/git-pull--rebase
Există 3 pași:
starea git
<<<<<<<<cap blablabla
git add solved_conflicts_files git commit -m 'îmbinare msg'
Ai putea repara merge conflictele într-un număr de moduri de fel de alte detalii.
Cred că adevărata cheie este de a ști cum se schimbă fluxul locale și depozitele de la distanță. Cheia pentru acest lucru este înțelegerea de urmărire ramuri. Am constatat că mă gândesc la urmărire ramură ca 'piesă lipsă în mijlocul' meu între mine locale, reale directorul de fișiere și de la distanță definit ca origine.
Am've personal a intrat în obiceiul de 2 lucruri pentru a ajuta evita acest lucru.
În loc de:
git add .
git commit -m"some msg"
Care are două dezavantaje -
a) Toate nou/schimbat fișiere, se adaugă și faptul că s-ar putea include unele modificări nedorite. b) nu't obține pentru a revizui lista de fișiere în primul rând.
Deci, în loc să fac:
git add file,file2,file3...
git commit # Then type the files in the editor and save-quit.
În acest fel vă sunt mult mai deliberată despre fișierele care se adaugă și veți obține, de asemenea, să revizuiască lista și cred că un pic mai mult timp folosind editorul pentru mesaj. Am găsi, de asemenea, îmbunătățește meu comite mesaje atunci când folosesc un editor de ecran complet, mai degrabă decât -m
opțiune.
[Update - pe măsură ce timpul a trecut am'am schimbat mai multe la:
git status # Make sure I know whats going on
git add .
git commit # Then use the editor
]
De asemenea (și mai relevante pentru situația dumneavoastră), am încerca să evite:
git pull
sau
git pull origin master.
pentru că trage implică o unificare și, dacă aveți modificări la nivel local, care ai n't vreau fuzionat puteți termina cu ușurință cu fuzionat cod și/sau fuziona conflicte de cod care ar trebui't au fost comasate.
În loc să încerc să fac
git checkout master
git fetch
git rebase --hard origin/master # or whatever branch I want.
De asemenea, puteți găsi acest util:
CoolAJ86's a răspunde sume destul de mult totul. În cazul în care aveți modificări în ambele ramuri în aceeași bucată de cod va trebui să facă un manual de îmbinare. Deschideți fișierul în conflict, în orice editor de text și ar trebui să vedeți următoarea structură.
(Code not in Conflict)
>>>>>>>>>>>
(first alternative for conflict starts here)
Multiple code lines here
===========
(second alternative for conflict starts here)
Multiple code lines here too
<<<<<<<<<<<
(Code not in conflict here)
Alege una dintre alternative sau o combinație a celor două într-un mod pe care doriți noul cod să fie, în timp ce eliminarea semne egale și paranteze unghiulare.
git commit -a -m "commit message"
git push origin master
git log --merge -p [[--] path]
Nu pare a funcționa întotdeauna pentru mine și, de obicei, se termină afișarea în fiecare comite că a fost diferit între cele două ramuri, acest lucru se întâmplă chiar și atunci când se utilizează --
pentru a separa calea de la comanda.
Ce fac eu pentru a rezolva această problemă este de a deschide două linii de comandă și într-un termen
git log ..$MERGED_IN_BRANCH --pretty=full -p [path]
și în alte
git log $MERGED_IN_BRANCH.. --pretty=full -p [path]
Înlocuirea $MERGED_IN_BRANCH cu ramura am fuzionat în si[cale]
cu fișier care este în conflict. Această comandă va conecta toate se angajează, în formă de patch-uri, între (..
) două comite. Dacă lăsați o parte goală ca în comenzile de mai sus git va utiliza automat " ȘEF " (ramura nu se contopesc în acest caz).
Acest lucru va permite să vedeți ce se angajează intrat în fișier în două ramuri după ce au divergente. De obicei face mult mai ușor pentru a rezolva conflictele.
Ca din 12 decembrie 2016, aveți posibilitatea să îmbinați ramuri și rezolvarea conflictelor pe github.com
Astfel, dacă nu't doriți să utilizați linia de comandă sau orice 3rd party instrumente care sunt oferite aici de vârstă răspunsuri, du-te cu GitHub's native instrument.
Acest post pe blog explică în detaliu, dar elementele de bază sunt ca la 'unirea' două ramuri prin intermediul UI, veți vedea acum o 'rezolva conflictele' opțiune care vă va duce la un editor care vă permite să se ocupe de aceste fuziona conflicte.
Am'm-a surprins nimeni nu a vorbit despre rezolvarea conflictului folosind "rabdare" cu îmbinare recursiv strategie. Pentru o mare fuziona conflict, folosind "rabdare" a dat rezultate bune pentru mine. Ideea este că acesta va încerca să se potrivească blocuri, mai degrabă decât linii individuale.
Dacă modificați indentare de programul tău de exemplu, default Git merge strategia uneori meciuri singur aparat dentar {
care aparține funcții diferite. Acest lucru este evitat cu "rabdare":
git merge -s recursive -X patience other-branch
Din documentația:
With this option, merge-recursive spends a little extra time to avoid
mismerges that sometimes occur due to unimportant matching lines
(e.g., braces from distinct functions). Use this when the branches to
be merged have diverged wildly.
Dacă aveți o îmbinare de conflict și vrei să vezi ceea ce altii au avut în minte atunci când modificarea ramura lor, l's, uneori, mai ușor de a compara ramura lor direct cu stramosul comun (de ramură). Pentru că puteți utiliza uni-base
:
git diff $(git merge-base <our-branch> <their-branch>) <their-branch>
De obicei, vrei doar pentru a vedea modificările pentru un anumit fișier:
git diff $(git merge-base <our-branch> <their-branch>) <their-branch> <file>
Eu întotdeauna urmați pașii de mai jos pentru a evita conflictele.
Acum puteți face același lucru și menține cât mai multe filiale locale care doriți și de a lucra simultan-mi fac doar un git checkout pentru filiala când este necesar.