git-merge - Online în cloud

PROGRAM:

NUME

git-merge - Uniți două sau mai multe istorii de dezvoltare împreună

REZUMAT

merge îmbina [-n] [--stat] [--no-commit] [--squash] [--[no-]edit]
[-s ] [-X ] [-S[ ]]
[--[no-]rerere-autoupdate] [-m ] [ ...]
merge îmbina CAP ...
merge îmbina --avorta

DESCRIERE

Încorporează modificări de la comit-urile numite (din momentul în care istoriile lor au diverjat
ramura curentă) în ramura curentă. Această comandă este folosită de merge trage la
încorporează modificări dintr-un alt depozit și poate fi folosit manual pentru a îmbina modificările din
o ramură în alta.

Să presupunem că există următorul istoric și ramura curentă este „master”:

A---B---C subiect
/
D---E---F---G maestru

Apoi „git merge topic” va relua modificările făcute pe ramura subiectului de când a divergit
de la master (adică, E) până la comiterea curentă (C) deasupra masterului și înregistrați rezultatul
într-un nou commit împreună cu numele celor două comite-uri părinte și un mesaj de jurnal de la
utilizator care descrie modificările.

A---B---C subiect
/\
D---E---F---G---H maestru

A doua sintaxa ( CAP ...) este susținută din motive istorice. Nu folosi
aceasta din linia de comandă sau în scripturi noi. Este la fel ca git merge -m
....

A treia sintaxă ("git merge --abort") poate fi rulată numai după ce a rezultat îmbinarea
conflicte. merge îmbina --avorta va anula procesul de îmbinare și va încerca să reconstruiască
stare înainte de îmbinare. Cu toate acestea, dacă au existat modificări necommitate la începutul îmbinării (și
mai ales dacă acele modificări au fost modificate în continuare după începerea îmbinării), merge îmbina
--avorta în unele cazuri, nu va putea reconstrui modificările originale (pre-imbinare).
Prin urmare:

avertizare: Alergare merge îmbina cu modificări netriviale neangajate este descurajat: în timp ce
posibil, s-ar putea să vă lase într-o stare care este greu de retras în cazul unui
conflict.

OPŢIUNI

--commit, --no-commit
Efectuați îmbinarea și confirmați rezultatul. Această opțiune poate fi folosită pentru a suprascrie
--nu-commit.

Cu --no-commit, efectuați îmbinarea, dar pretindeți că îmbinarea a eșuat și nu comiteți automat,
pentru a oferi utilizatorului șansa de a inspecta și de a modifica în continuare rezultatul îmbinării înainte
comiterea.

--edit, -e, --no-edit
Invocați un editor înainte de a efectua îmbinarea mecanică cu succes pentru a edita în continuare
mesaj de îmbinare generat automat, astfel încât utilizatorul să poată explica și justifica îmbinarea. The
Opțiunea --no-edit poate fi folosită pentru a accepta mesajul generat automat (în general, acesta este
descurajat). Opțiunea --edit (sau -e) este încă utilă dacă oferiți o schiță
mesaj cu opțiunea -m din linia de comandă și doriți să-l editați în editor.

Scripturile mai vechi pot depinde de comportamentul istoric de a nu permite utilizatorului să editeze
mesajul jurnal de îmbinare. Ei vor vedea un editor deschis când rulează git merge. A face
este mai ușor să ajustați astfel de scripturi la comportamentul actualizat, variabila de mediu
GIT_MERGE_AUTOEDIT poate fi setat la nu la începutul acestora.

--ff
Când îmbinarea se rezolvă ca o derulare rapidă înainte, actualizați doar indicatorul de ramură, fără
crearea unui commit de îmbinare. Acesta este comportamentul implicit.

--nu-ff
Creați un commit de îmbinare chiar și atunci când îmbinarea se rezolvă ca o derulare rapidă înainte. Acesta este
comportament implicit la îmbinarea unei etichete adnotate (și eventual semnate).

--ff-doar
Refuzați să fuzionați și să ieșiți cu o stare diferită de zero, cu excepția cazului în care HEAD-ul actual este deja
actualizate sau îmbinarea poate fi rezolvată ca o derulare rapidă.

--log[= ], --no-log
Pe lângă numele de ramuri, completați mesajul de jurnal cu descrieri dintr-un rând de la
cel mult comite-uri reale care sunt fuzionate. Vezi si git-fmt-merge-msg(1).

Cu --no-log nu listați descrierile pe o linie din comiterile reale care sunt îmbinate.

--stat, -n, --no-stat
Afișați un diffstat la sfârșitul îmbinării. Diffstat-ul este, de asemenea, controlat de
opțiunea de configurare merge.stat.

Cu -n sau --no-stat nu afișează un diffstat la sfârșitul îmbinării.

--dovleac, --no-dovleac
Produceți arborele de lucru și starea indexului ca și cum ar fi avut loc o îmbinare reală (cu excepția fișierului
îmbinați informații), dar nu efectuați de fapt o comitere, nu mutați HEAD sau nu înregistrați
$GIT_DIR/MERGE_HEAD (pentru a determina următoarea comandă git commit să creeze un comit de îmbinare).
Acest lucru vă permite să creați un singur commit deasupra ramurii curente al cărei efect este
la fel ca fuzionarea unei alte ramuri (sau mai multe în cazul unei caracatițe).

Cu --no-squash, efectuați îmbinarea și comiteți rezultatul. Această opțiune poate fi folosită pentru
override --dovleac.

-s , --strategie=
Utilizați strategia de îmbinare dată; pot fi furnizate de mai multe ori pentru a le specifica în
pentru ca acestea să fie încercate. Dacă nu există opțiunea -s, este o listă încorporată de strategii
folosit in schimb (merge fuziune-recursivă la unirea unui singur cap, merge îmbinare-caracatiță
in caz contrar).

-X , --strategy-option=
Treceți opțiunea specifică strategiei de îmbinare la strategia de îmbinare.

--verify-signatures, --no-verify-signatures
Verificați dacă commit-urile care sunt îmbinate au semnături GPG bune și de încredere și anulați
fuzionarea în cazul în care nu o fac.

--rezumat, --nu-rezumat
Sinonime pentru --stat și --no-stat; acestea sunt depreciate și vor fi eliminate în
viitor.

-q, --liniște
Operați în liniște. Implica --no-progres.

-v, --verbos
Fii verbis.

--progres, --no-progres
Activați/dezactivați în mod explicit progresul. Dacă niciunul nu este specificat, progresul este afișat dacă
eroarea standard este conectată la un terminal. Rețineți că nu toate strategiile de îmbinare pot
sprijină raportarea progresului.

-S[ ], --gpg-sign[= ]
GPG semnează comiterea de îmbinare rezultată. Argumentul keyid este opțional și este implicit
identitatea commiterului; dacă este specificat, trebuie să fie lipit de opțiunea fără spațiu.

-m
Setați mesajul de comitere pentru a fi utilizat pentru comiterea de îmbinare (în cazul în care este creat unul).

Dacă este specificat --log, un scurt jurnal al comitărilor care sunt îmbinate va fi adăugat la
mesajul specificat.

merge fmt-merge-msg comanda poate fi folosită pentru a oferi o valoare implicită bună pentru automate merge
îmbina invocaţii. Mesajul automat poate include descrierea filialei.

--[no-]rerere-autoupdate
Permiteți mecanismului rerere să actualizeze indexul cu rezultatul auto-conflictului
rezoluție dacă este posibil.

--avorta
Anulați procesul actual de soluționare a conflictului și încercați să reconstruiți pre-fuzionarea
de stat.

Dacă au fost prezente modificări ale arborelui de lucru necommitate când a început îmbinarea, merge îmbina
--avorta în unele cazuri nu va putea reconstrui aceste modificări. Este deci
se recomandă să comiteți sau să păstrați întotdeauna modificările înainte de a rula merge îmbina.

merge îmbina --avorta este echivalent cu merge reseta --combina când MERGE_HEAD este prezent.

...
Se angajează, de obicei, alți șefi de sucursală, să fuzioneze în sucursala noastră. Precizând mai mult decât
un commit va crea o fuziune cu mai mult de doi părinți (numit cu afecțiune un
fuziunea caracatiței).

Dacă nu este dat niciun commit din linia de comandă, îmbinați ramurile de urmărire la distanță care
ramura curentă este configurată pentru a fi utilizată în amonte. Vezi și configurația
secțiunea acestei pagini de manual.

Când este specificat FETCH_HEAD (și nici un alt commit), ramurile înregistrate în
Fișierul .git/FETCH_HEAD prin invocarea anterioară a git fetch pentru îmbinare sunt îmbinați cu
ramura actuală.

PRE-COMPUNERE VERIFICĂRI

Înainte de a aplica modificări din exterior, ar trebui să vă puneți propria muncă în formă și să vă implicați
la nivel local, deci nu va fi zdrobit dacă există conflicte. Vezi si git-stash(1). merge
trage si merge îmbina se va opri fără a face nimic atunci când modificările locale necommitate se suprapun
cu dosare care merge trage/merge îmbina poate fi necesar să se actualizeze.

Pentru a evita înregistrarea modificărilor fără legătură în comiterea de îmbinare, merge trage si merge îmbina va fi, de asemenea,
anulați dacă există modificări înregistrate în index referitor la comiterea HEAD. (Unu
excepția este atunci când intrările de index modificate sunt în starea care ar rezulta din
îmbina deja.)

Dacă toate commit-urile numite sunt deja strămoșii HEAD, merge îmbina va ieși devreme cu
mesajul „Deja actualizat”.

REPEDE INAINTE MERGE

Adesea, actualul cap de ramură este un strămoș al commit-ului numit. Acesta este cel mai comun
caz mai ales atunci când este invocat din merge trage: urmăriți un depozit din amonte, dvs
nu au efectuat modificări locale și acum doriți să actualizați la o versiune mai nouă în amonte.
În acest caz, un nou commit nu este necesar pentru a stoca istoricul combinat; în schimb, CAPUL
(împreună cu indexul) este actualizat pentru a indica comiterea numită, fără a crea un plus
comite de îmbinare.

Acest comportament poate fi suprimat cu opțiunea --no-ff.

TRUE MERGE

Cu excepția unei îmbinări rapid-forward (vezi mai sus), ramurile care urmează să fie îmbinate trebuie să fie legate
împreună printr-un comit de fuziune care îi are pe amândoi ca părinți.

Se comite o versiune îmbinată care reconciliază modificările din toate ramurile care urmează să fie îmbinate și
HEAD, indexul și arborele de lucru sunt actualizate la acesta. Este posibil sa aiba modificari
în arborele de lucru atâta timp cât acestea nu se suprapun; actualizarea le va păstra.

Când nu este evident cum să reconciliezi modificările, se întâmplă următoarele:

1. Indicatorul HEAD rămâne același.

2. Ref-ul MERGE_HEAD este setat să indice celălalt cap de ramură.

3. Căile care s-au îmbinat curat sunt actualizate atât în ​​fișierul index, cât și în arborele dvs. de lucru.

4. Pentru căile aflate în conflict, fișierul index înregistrează până la trei versiuni: etapa 1 stochează fișierul
versiunea din strămoșul comun, etapa 2 din HEAD și etapa 3 din MERGE_HEAD (dvs.
poate inspecta etapele cu git ls-files -u). Fișierele arborelui de lucru conțin fișierul
rezultat al programului „merge”; adică rezultatele îmbinării în trei căi cu markeri de conflict familiari
<<< === >>>.

5. Nu se fac alte modificări. În special, modificările locale pe care le-ați avut înainte
fuziunea începută va rămâne aceeași, iar intrările de index ale acestora rămân așa cum erau,
adică potrivirea HEAD.

Dacă ați încercat o îmbinare care a dus la conflicte complexe și doriți să o luați de la capăt, puteți
recuperați cu git merge --abort.

FUNZIONARE TAG

Când îmbinați o etichetă adnotată (și posibil semnată), Git creează întotdeauna o comitere de îmbinare
chiar dacă o îmbinare rapid-forward este posibilă, iar șablonul de mesaj de confirmare este pregătit cu
mesajul etichetei. În plus, dacă eticheta este semnată, verificarea semnăturii este raportată ca a
comentați în șablonul de mesaj. Vezi si git-tag(1).

Când vrei să te integrezi doar cu munca care duce la angajamentul care se întâmplă să fie
etichetat, de exemplu, sincronizarea cu un punct de lansare în amonte, este posibil să nu doriți să faceți un
comitere de îmbinare inutilă.

Într-un astfel de caz, puteți „despacheta” eticheta înainte de a o alimenta pentru a merge sau a trece prin git merge
--ff-doar atunci când nu aveți nicio lucrare pe cont propriu. de exemplu

git fetch origine
git merge v1.2.3^0
git merge --ff-only v1.2.3

CUM CONFLICTE SUNT PREZENTAT

În timpul unei îmbinări, fișierele arbore de lucru sunt actualizate pentru a reflecta rezultatul îmbinării.
Printre modificările aduse versiunii strămoșului comun, cele care nu se suprapun (adică
ați schimbat o zonă a fișierului în timp ce cealaltă parte a lăsat acea zonă intactă sau invers)
sunt încorporate în rezultatul final text. Când ambele părți au făcut modificări la același
Cu toate acestea, Git nu poate alege aleatoriu o parte peste cealaltă și îți cere să rezolvi
lăsând ceea ce ambele părți au făcut în acea zonă.

Implicit, Git folosește același stil ca cel folosit de programul „merge” din RCS
suită pentru a prezenta o astfel de bucată conflictuală, ca aceasta:

Iată linii care sunt fie neschimbate față de cele comune
strămoș, sau rezolvat curat pentru că doar o parte sa schimbat.
<<<<<<< dvs.:sample.txt
Rezolvarea conflictelor este grea;
Să mergem la cumpărături.
=======
Git facilitează rezolvarea conflictelor.
>>>>>>> lor:sample.txt
Și iată o altă linie care este curată rezolvată sau nemodificată.

Zona în care au avut loc o pereche de modificări conflictuale este marcată cu marcatori <<<<<<<,
======= și >>>>>>>. Partea dinaintea ======= este de obicei partea ta, iar partea
după aceea este de obicei partea lor.

Formatul implicit nu arată ceea ce a spus originalul în zona conflictuală. Tu
nu pot spune câte rânduri sunt șterse și înlocuite cu observația lui Barbie din partea ta. The
singurul lucru pe care îl poți spune este că partea ta vrea să spună că este greu și că ai prefera să pleci
cumpărături, în timp ce cealaltă parte vrea să pretindă că este ușor.

Un stil alternativ poate fi folosit prin setarea configurației „merge.conflictStyle”.
variabilă la „dif3”. În stilul „diff3”, conflictul de mai sus poate arăta astfel:

Iată linii care sunt fie neschimbate față de cele comune
strămoș, sau rezolvat curat pentru că doar o parte sa schimbat.
<<<<<<< dvs.:sample.txt
Rezolvarea conflictelor este grea;
Să mergem la cumpărături.
|||||||
Rezolvarea conflictelor este grea.
=======
Git facilitează rezolvarea conflictelor.
>>>>>>> lor:sample.txt
Și iată o altă linie care este curată rezolvată sau nemodificată.

În plus față de marcatorii <<<<<<<, ======= și >>>>>>>, folosește un alt ||||||| marker
care este urmat de textul original. Puteți spune că originalul tocmai a declarat un fapt,
iar partea ta a cedat pur și simplu acelei declarații și a renunțat, în timp ce cealaltă parte a încercat
au o atitudine mai pozitivă. Uneori puteți veni cu o rezoluție mai bună prin
vizualizarea originalului.

CUM LA REZOLVA CONFLICTE

După ce vezi un conflict, poți face două lucruri:

· Decideți să nu fuzionați. Singurele curățări de care aveți nevoie sunt să resetați fișierul index la
HEAD se angajează să inverseze 2. și să curețe modificările arborelui de lucru făcute de 2. și 3.; git
merge --abort poate fi folosit pentru aceasta.

· Rezolvarea conflictelor. Git va marca conflictele în arborele de lucru. Editați fișierele
în formă și merge adăuga le la index. Utilizare merge comite pentru a pecetlui afacerea.

Puteți rezolva conflictul cu o serie de instrumente:

· Utilizați un instrument de îmbinare. git mergetool pentru a lansa un mergetool grafic care vă va funcționa
prin fuziune.

· Uită-te la diferențe. git diff va afișa o diferență cu trei căi, evidențiind modificările de la
ambele versiuni HEAD și MERGE_HEAD.

· Uită-te la diferențele de la fiecare ramură. git log --merge -p va arăta mai întâi diferențele
pentru versiunea HEAD și apoi versiunea MERGE_HEAD.

· Uită-te la originale. git show :1:filename arată strămoșul comun, git show
:2:filename arată versiunea HEAD, iar git show :3:filename arată MERGE_HEAD
versiune.

EXEMPLE

· Îmbină ramurile remedieri și îmbunătățiri peste ramura curentă, făcând o caracatiță
combina:

$ git merge remediază îmbunătățiri

· Îmbină ramura învechită în ramura actuală, folosind strategia noastră de îmbinare:

$ git merge -s al nostru învechit

· Îmbinați menținerea ramurilor în ramura curentă, dar nu faceți un nou commit
automat:

$ git merge --no-commit maint

Acesta poate fi folosit atunci când doriți să includeți modificări suplimentare la îmbinare sau doriți
scrieți propriul mesaj de comitere de îmbinare.

Ar trebui să vă abțineți de la a abuza de această opțiune pentru a introduce modificări substanțiale într-o fuziune
comite. Mici remedieri, cum ar fi bumping release/version name ar fi acceptabile.

MERGE STRATEGII

Mecanismul de îmbinare (comenzile git merge și git pull) permite backend-ul îmbina strategii
pentru a fi aleasă cu opțiunea -s. Unele strategii își pot lua și propriile opțiuni, care pot fi
a trecut prin a da -X argumente pentru git merge și/sau git pull.

rezolvă
Acest lucru poate rezolva doar două capete (adică ramura curentă și o altă ramură pe care ați tras-o
de la) folosind un algoritm de îmbinare în trei căi. Încearcă să detecteze cu atenție îmbinarea încrucișată
ambiguități și este considerat în general sigur și rapid.

recursiv
Acest lucru poate rezolva doar două capete folosind un algoritm de îmbinare în trei căi. Când există mai mult de
un strămoș comun care poate fi folosit pentru îmbinarea în 3 căi, creează un arbore îmbinat al
strămoși comuni și îl folosește ca arbore de referință pentru îmbinarea în trei căi. Aceasta are
S-a raportat că are ca rezultat mai puține conflicte de îmbinare fără a provoca îmbinări greșite de către teste
realizat pe comiterile de îmbinare reale preluate din istoricul dezvoltării kernel-ului Linux 2.6.
În plus, aceasta poate detecta și gestiona fuziuni care implică redenumiri. Aceasta este valoarea implicită
strategia de îmbinare atunci când trageți sau îmbinați o ramură.

recursiv strategia poate lua următoarele opțiuni:

suporta
Această opțiune obligă părțile aflate în conflict să fie rezolvate automat în mod curat prin favorizare al nostru
versiune. Schimbările din celălalt copac care nu intră în conflict cu partea noastră sunt
reflectată în rezultatul îmbinării. Pentru un fișier binar, este preluat întregul conținut
din partea noastră.

Acest lucru nu trebuie confundat cu suporta strategia de îmbinare, care nici măcar nu arată
la ceea ce conţine celălalt copac. Renunță la tot ce a făcut celălalt copac,
declararea al nostru istoria conține tot ce s-a întâmplat în ea.

a lor
Acesta este opusul suporta.

răbdare
Cu această opțiune, fuziune-recursivă 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 distinct
funcții). Folosiți-l atunci când ramurile care urmează să fie îmbinate s-au divergent în mod sălbatic. Vezi si
git-diff(1) --răbdare.

diff-algorithm=[răbdare|minimal|histogramă|myers]
Spune fuziune-recursivă pentru a utiliza un algoritm diferit, care poate ajuta la evitarea
îmbinări greșite care apar din cauza liniilor de potrivire neimportante (cum ar fi bretele de la
funcţii distincte). Vezi si git-diff(1) --algoritm-dif.

ignora-schimbarea-spațială, ignora-tot-spațiul, ignora-spațiul-la-eol
Tratează liniile cu tipul indicat de modificare a spațiului alb ca neschimbate pentru
de dragul unei fuziuni în trei. Modificările spațiilor albe combinate cu alte modificări ale unei linii
nu sunt ignorate. Vezi si git-diff(1) -b, -w și --ignore-space-at-eol.

· Dacă lor versiunea introduce doar modificări de spații albe la o linie, al nostru versiunea este
folosit;

· Dacă al nostru versiunea introduce modificări de spații albe dar lor versiunea include a
schimbare substanțială, lor se folosește versiunea;

· În caz contrar, fuziunea se desfășoară în mod obișnuit.

renormaliza
Aceasta rulează o verificare virtuală și o înregistrare a tuturor celor trei etape ale unui fișier când
rezolvarea unei îmbinări în trei. Această opțiune este menită să fie utilizată la îmbinarea ramurilor
cu filtre curate diferite sau reguli de normalizare de final de linie. A se vedea „Imbinare
sucursale cu atribute diferite de check-in/checkout" în gitattributes(5) pentru
Detalii.

nu-renormalizare
Dezactivează opțiunea de renormalizare. Aceasta anulează merge.renormalize
variabila de configurare.

rename-threshold=
Controlează pragul de similitudine utilizat pentru detectarea redenumirii. Vezi si git-diff(1)
-M.

subarbore[= ]
Această opțiune este o formă mai avansată de subarbore strategie, unde face strategia
o ghicire a modului în care doi copaci trebuie mutați pentru a se potrivi unul cu celălalt atunci când se îmbină.
În schimb, calea specificată este prefixată (sau eliminată de la început).
forma a doi copaci care să se potrivească.

poulpe
Acest lucru rezolvă cazurile cu mai mult de două capete, dar refuză să facă o fuziune complexă
necesită rezoluție manuală. Este destinat în primul rând să fie utilizat pentru gruparea ramurilor subiectului
capete împreună. Aceasta este strategia de îmbinare implicită atunci când trageți sau îmbinați mai mult de
o ramură.

suporta
Acest lucru rezolvă orice număr de capete, dar arborele rezultat al îmbinării este întotdeauna acesta
a capului actual de ramură, ignorând efectiv toate modificările din toate celelalte ramuri.
Este menit să fie folosit pentru a înlocui istoria veche de dezvoltare a ramurilor laterale. Notă
că aceasta este diferită de opțiunea -Xours la recursiv strategia de fuziune.

subarbore
Aceasta este o strategie recursivă modificată. La îmbinarea arborilor A și B, dacă B corespunde
un subarboresc al lui A, B este mai întâi ajustat pentru a se potrivi cu structura arborescentă a lui A, în loc de
citind copacii la același nivel. Această ajustare se face și la comun
arborele strămoș.

Cu strategiile care folosesc îmbinarea în trei direcții (inclusiv cea implicită, recursiv), dacă o schimbare
se face pe ambele ramuri, dar ulterior revenit pe una dintre ramuri, acea modificare va fi
prezent în rezultatul comasat; unii oameni consideră acest comportament confuz. Se întâmplă pentru că
numai capetele și baza de îmbinare sunt luate în considerare atunci când se efectuează o îmbinare, nu
individual se angajează. Prin urmare, algoritmul de îmbinare consideră modificarea inversată ca nu
schimbă deloc și înlocuiește versiunea modificată.

CONFIGURARE

merge.conflictStyle
Specificați stilul în care sunt scrise părțile aflate în conflict în fișierele arbore de lucru
combina. Valoarea implicită este „merge”, care arată un marcator de conflict <<<<<<<, modificările efectuate de
pe o parte, un marcator ========, modificările făcute de cealaltă parte și apoi un marcator >>>>>>>.
Un stil alternativ, „diff3”, adaugă un ||||||| marker și textul original înainte de
======= marker.

merge.defaultToUpstream
Dacă merge este apelată fără niciun argument de comitere, îmbinați ramurile din amonte configurate
pentru ramura curentă folosind ultimele lor valori observate stocate în lor
sucursale de urmărire la distanță. Valorile ramurii. .imbina acest nume
ramurile de la telecomandă numite după ramură. .telecomanda sunt consultate, si
apoi sunt mapate prin telecomandă. .aduceți la urmărirea de la distanță corespunzătoare
ramuri, iar vârfurile acestor ramuri de urmărire sunt îmbinate.

îmbinare.ff
În mod implicit, Git nu creează o comitere de îmbinare suplimentară atunci când îmbină o comitere care este a
descendent al actualului commit. În schimb, vârful ramurii curente este
redirecționat rapid. Când este setată la false, această variabilă îi spune lui Git să creeze o îmbinare suplimentară
commit într-un astfel de caz (echivalent cu a da opțiunea --no-ff din linia de comandă).
Când este setat la numai, sunt permise numai astfel de îmbinări cu derulare rapidă înainte (echivalent cu a da codul
--ff-only opțiunea din linia de comandă).

merge.branchdesc
Pe lângă numele de ramuri, completați mesajul de jurnal cu textul de descriere a ramurilor
asociate cu acestea. Implicit la fals.

îmbinare.log
Pe lângă numele de ramuri, completați mesajul de jurnal cu cel mult cele specificate
numărul de descrieri pe o linie din comiterile reale care sunt îmbinate.
Valoarea implicită la fals, iar adevărat este un sinonim pentru 20.

merge.renameLimit
Numărul de fișiere de luat în considerare atunci când se efectuează detectarea redenumirii în timpul unei îmbinări; dacă
nespecificat, valoarea implicită pentru diff.renameLimit.

îmbinare.renormaliza
Spune-i lui Git că reprezentarea canonică a fișierelor din depozit s-a schimbat
timp (de exemplu, comite mai devreme fișierele text de înregistrare cu terminații de linie CRLF, dar cele recente
utilizați terminațiile de linie LF). Într-un astfel de depozit, Git poate converti datele înregistrate în
se angajează într-o formă canonică înainte de a efectua o îmbinare pentru a reduce conflictele inutile.
Pentru mai multe informații, consultați secțiunea „Îmbinarea sucursalelor cu checkin/checkout diferite
atribute" în gitattributes(5).

merge.stat
Indiferent dacă se imprimă diffstat-ul dintre ORIG_HEAD și rezultatul îmbinării la sfârșitul
combina. Adevărat în mod implicit.

îmbinare.instrument
Controlează ce instrument de îmbinare este utilizat de git-mergetool(1). Lista de mai jos arată cele valide
valori încorporate. Orice altă valoare este tratată ca un instrument de îmbinare personalizat și necesită ca a
instrumentul de îmbinare corespunzător. Variabila .cmd este definită.

· araxis

· bc

· bc3

· codecompare

· deltawalker

· diffmerge

· difuză

· emerge

· apar

· gvimdiff

· gvimdiff2

· gvimdiff3

· kdiff3

· amestec

· openiff

· p4merge

· tkdiff

· broasca testoasa

· vimdiff

· vimdiff2

· vimdiff3

· winmerge

· xxdiff

îmbinare.verbositate
Controlează cantitatea de ieșire afișată de strategia de îmbinare recursivă. Ieșiri de nivel 0
nimic în afară de un mesaj de eroare final dacă au fost detectate conflicte. Doar ieșiri de nivel 1
conflicte, 2 iesiri conflicte si modificari fisiere. Nivelul 5 și peste ieșiri de depanare
informație. Valoarea implicită este nivelul 2. Poate fi suprascris de către GIT_MERGE_VERBOSITY
variabilă de mediu.

combina. .Nume
Definește un nume care poate fi citit de om pentru un driver personalizat de îmbinare de nivel scăzut. Vedea
gitattributes(5) pentru detalii.

combina. .conducător auto
Definește comanda care implementează un driver personalizat de îmbinare de nivel scăzut. Vedea
gitattributes(5) pentru detalii.

combina. .recursiv
Denumește un driver de îmbinare de nivel scăzut pentru a fi utilizat atunci când se efectuează o îmbinare internă între
strămoși comuni. Vedea gitattributes(5) pentru detalii.

ramură. .mergeOptions
Setează opțiunile implicite pentru îmbinarea în ramură . Sintaxa și opțiunile acceptate
sunt la fel ca cele ale merge îmbina, dar valorile opțiunilor care conțin caractere spații albe
momentan nu sunt acceptate.

Utilizați git-merge online folosind serviciile onworks.net