git-merge - Online sa Cloud

PROGRAMA:

NAME

git-merge - Magsama ng dalawa o higit pang mga kasaysayan ng pag-unlad

SINOPSIS

pumunta pagsamahin [-n] [--stat] [--no-commit] [--squash] [--[no-]edit]
[-s ] [-X ] [-S[ ]]
[--[no-]rerere-autoupdate] [-m ] [ ...]
pumunta pagsamahin ULO ...
pumunta pagsamahin --abort

DESCRIPTION

Isinasama ang mga pagbabago mula sa pinangalanang mga commit (mula noong ang kanilang mga kasaysayan ay naghiwalay mula sa
ang kasalukuyang sangay) sa kasalukuyang sangay. Ang utos na ito ay ginagamit ng pumunta paghila sa
isama ang mga pagbabago mula sa isa pang repository at maaaring gamitin sa pamamagitan ng kamay upang pagsamahin ang mga pagbabago mula sa
isang sangay patungo sa isa pa.

Ipagpalagay na ang sumusunod na kasaysayan ay umiiral at ang kasalukuyang sangay ay "master":

A---B---C paksa
/
D---E---F---G master

Pagkatapos ay ire-replay ng "git merge topic" ang mga pagbabagong ginawa sa sangay ng paksa mula nang maghiwalay ito
mula sa master (ibig sabihin, E) hanggang sa kasalukuyan nitong commit (C) sa ibabaw ng master, at itala ang resulta
sa isang bagong commit kasama ang mga pangalan ng dalawang parent commit at isang log message mula sa
user na naglalarawan ng mga pagbabago.

A---B---C paksa
/\
D---E---F---G---H master

Ang pangalawang syntax ( ULO ...) ay sinusuportahan para sa makasaysayang mga kadahilanan. Huwag gamitin
ito mula sa command line o sa mga bagong script. Ito ay kapareho ng git merge -m
....

Ang pangatlong syntax ("git merge --abort") ay maaari lamang patakbuhin pagkatapos magresulta ang pagsasanib sa
mga salungatan. pumunta pagsamahin --abort ay abort ang proseso ng pagsasanib at susubukang buuin muli ang
pre-merge na estado. Gayunpaman, kung may mga hindi nakatalagang pagbabago noong nagsimula ang pagsasanib (at
lalo na kung ang mga pagbabagong iyon ay higit na binago pagkatapos na simulan ang pagsasanib), pumunta pagsamahin
--abort sa ilang mga kaso ay hindi na muling buuin ang orihinal (pre-merge) na mga pagbabago.
Samakatuwid:

babala: Tumatakbo pumunta pagsamahin na may mga di-maliit na pagbabago na hindi nakatuon ay nasiraan ng loob: habang
posible, maaari kang mag-iwan sa isang estado na mahirap i-back out sa kaso ng a
salungatan.

Opsyon

--commit, --no-commit
Isagawa ang merge at i-commit ang resulta. Maaaring gamitin ang opsyong ito para i-override
--no-commit.

Gamit ang --no-commit isagawa ang pagsasanib ngunit magpanggap na nabigo ang pagsasanib at huwag mag-autocommit,
upang bigyan ang user ng pagkakataong siyasatin at higit pang i-tweak ang resulta ng pagsasanib bago
nangangako.

--edit, -e, --no-edit
Humingi ng isang editor bago gumawa ng matagumpay na mechanical merge upang higit pang i-edit ang
awtomatikong nabuong mensahe ng pagsasanib, upang maipaliwanag at mabigyang-katwiran ng user ang pagsasanib. Ang
--no-edit na opsyon ay maaaring gamitin upang tanggapin ang awtomatikong nabuong mensahe (ito ay karaniwang
pinanghinaan ng loob). Ang --edit (o -e) na opsyon ay kapaki-pakinabang pa rin kung magbibigay ka ng draft
mensahe na may opsyong -m mula sa command line at gustong i-edit ito sa editor.

Maaaring nakadepende ang mga lumang script sa dating gawi ng hindi pagpayag sa user na mag-edit
ang mensahe ng merge log. Makakakita sila ng isang editor na binuksan kapag nagpatakbo sila ng git merge. Gumawa
mas madaling ayusin ang mga naturang script sa na-update na pag-uugali, ang variable ng kapaligiran
Maaaring itakda ang GIT_MERGE_AUTOEDIT sa hindi sa simula ng mga ito.

--ff
Kapag nalutas ang pagsasanib bilang isang fast-forward, i-update lamang ang pointer ng sangay, nang wala
paglikha ng isang merge commit. Ito ang default na pag-uugali.

--hindi-ff
Gumawa ng merge commit kahit na ang merge ay nalutas bilang fast-forward. Ito ang
default na gawi kapag pinagsasama ang isang annotated (at posibleng nilagdaan) na tag.

--ff-lamang
Tumangging pagsamahin at lumabas na may hindi zero na katayuan maliban kung ang kasalukuyang HEAD ay mayroon na
up-to-date o ang pagsasanib ay maaaring malutas bilang isang fast-forward.

--log[= ], --walang-log
Bilang karagdagan sa mga pangalan ng sangay, punan ang mensahe ng log ng isang linyang paglalarawan mula sa
Kadalasan mga aktwal na commit na pinagsasama. Tingnan din git-fmt-merge-msgNa (1).

Sa --no-log huwag ilista ang isang linyang paglalarawan mula sa aktwal na mga commit na pinagsasama.

--stat, -n, --no-stat
Magpakita ng diffstat sa dulo ng pagsasama. Ang diffstat ay kinokontrol din ng
opsyon sa pagsasaayos merge.stat.

Sa -n o --no-stat ay hindi nagpapakita ng diffstat sa dulo ng pagsasama.

--kalabasa, --walang-kalabasa
Gumawa ng working tree at index state na parang isang totoong pagsasanib ang nangyari (maliban sa
pagsamahin ang impormasyon), ngunit hindi aktwal na gumawa ng isang pangako, ilipat ang HEAD, o itala
$GIT_DIR/MERGE_HEAD (upang maging sanhi ng susunod na git commit command upang lumikha ng isang merge commit).
Binibigyang-daan ka nitong lumikha ng isang commit sa itaas ng kasalukuyang sangay na ang epekto ay
katulad ng pagsasama-sama ng isa pang sangay (o higit pa sa kaso ng isang octopus).

Gamit ang --no-squash isagawa ang merge at i-commit ang resulta. Ang pagpipiliang ito ay maaaring gamitin sa
override --kalabasa.

-s , --diskarte=
Gamitin ang ibinigay na diskarte sa pagsasanib; maaaring ibigay ng higit sa isang beses upang tukuyin ang mga ito sa
order dapat silang subukan. Kung walang -s na opsyon, ang isang built-in na listahan ng mga diskarte ay
ginamit sa halip (pumunta merge-recursive kapag pinagsama ang isang ulo, pumunta merge-octopus
kung hindi man).

-X , --diskarte-opsyon=
Ipasa ang tukoy na opsyon sa pagsasama-sama hanggang sa diskarte sa pagsasanib.

--verify-signatures, --no-verify-signatures
I-verify na ang mga commit na pinagsasama ay may maganda at pinagkakatiwalaang mga lagda ng GPG at abort
ang pagsasanib kung sakaling hindi.

--buod, --walang-buod
Mga kasingkahulugan ng --stat at --no-stat; ang mga ito ay hindi na ginagamit at aalisin sa
hinaharap.

-q, --tahimik
Magpatakbo nang tahimik. Nagpapahiwatig --walang pag-unlad.

-v, --verbose
Maging verbose.

--pag-unlad, --walang pag-unlad
I-on/i-off nang tahasan ang pag-usad. Kung walang tinukoy, ang pag-unlad ay ipinapakita kung
ang karaniwang error ay konektado sa isang terminal. Tandaan na hindi lahat ng mga diskarte sa pagsasanib ay maaaring
suportahan ang pag-uulat ng pag-unlad.

-S[ ], --gpg-sign[= ]
GPG-lagdaan ang resultang merge commit. Ang keyid argument ay opsyonal at default sa
ang pagkakakilanlan ng committer; kung tinukoy, dapat itong nakadikit sa opsyon nang walang puwang.

-m
Itakda ang commit message na gagamitin para sa merge commit (kung sakaling malikha ang isa).

Kung tinukoy ang --log, ang shortlog ng mga commit na pinagsasama ay idaragdag sa
tinukoy na mensahe.

Ang pumunta fmt-merge-msg command ay maaaring gamitin upang magbigay ng isang magandang default para sa automated pumunta
pagsamahin mga panawagan. Maaaring kasama sa awtomatikong mensahe ang paglalarawan ng sangay.

--[no-]rerere-autoupdate
Payagan ang mekanismo ng rerere na i-update ang index na may resulta ng auto-conflict
resolusyon kung maaari.

--abort
I-abort ang kasalukuyang proseso ng paglutas ng salungatan, at subukang buuin muli ang pre-merge
estado.

Kung may mga hindi nakatalagang pagbabago sa worktree na naroroon noong nagsimula ang pagsasanib, pumunta pagsamahin
--abort sa ilang mga kaso ay hindi na muling buuin ang mga pagbabagong ito. Ito ay samakatuwid
inirerekomenda na palaging i-commit o itago ang iyong mga pagbabago bago tumakbo pumunta pagsamahin.

pumunta pagsamahin --abort ay katumbas ng pumunta i-reset ang --pagsamahin kapag naroroon ang MERGE_HEAD.

...
Nangangako, karaniwang iba pang mga pinuno ng sangay, na sumanib sa aming sangay. Tinutukoy ang higit sa
ang isang commit ay lilikha ng isang pagsasanib na may higit sa dalawang magulang (magiliw na tinatawag na an
Octopus merge).

Kung walang commit na ibinigay mula sa command line, pagsamahin ang remote-tracking branch na iyon
ang kasalukuyang sangay ay naka-configure upang gamitin bilang upstream nito. Tingnan din ang pagsasaayos
seksyon ng manwal na pahinang ito.

Kapag ang FETCH_HEAD (at walang ibang commit) ay tinukoy, ang mga sangay ay naitala sa
.git/FETCH_HEAD file sa pamamagitan ng nakaraang invocation ng git fetch para sa pagsasama ay pinagsama sa
ang kasalukuyang sangay.

PRE-MERGE MGA CHECK

Bago mag-apply ng mga pagbabago sa labas, dapat mong makuha ang iyong sariling trabaho sa mabuting kalagayan at nakatuon
lokal, kaya hindi ito magiging clobbered kung may mga salungatan. Tingnan din git-stashNa (1). pumunta
paghila at pumunta pagsamahin ay titigil nang hindi gumagawa ng anuman kapag nag-overlap ang mga lokal na pagbabagong hindi nakatuon
kasama ang mga file na iyon pumunta paghila/pumunta pagsamahin maaaring kailanganin na mag-update.

Upang maiwasan ang pagtatala ng mga hindi nauugnay na pagbabago sa merge commit, pumunta paghila at pumunta pagsamahin nasain din
i-abort kung mayroong anumang pagbabagong nakarehistro sa index na nauugnay sa HEAD commit. (Isa
Ang exception ay kapag ang binagong mga entry sa index ay nasa estado na magreresulta mula sa
pagsamahin na.)

Kung ang lahat ng pinangalanang commit ay mga ninuno na ng HEAD, pumunta pagsamahin ay lalabas ng maaga kasama ang
mensahe "Napapanahon na."

FAST-FORWARD Sumanib

Kadalasan ang kasalukuyang pinuno ng sangay ay isang ninuno ng pinangalanang commit. Ito ang pinakakaraniwan
kaso lalo na kapag invoke from pumunta paghila: sinusubaybayan mo ang isang upstream repository, ikaw
walang ginawang lokal na pagbabago, at ngayon ay gusto mong mag-update sa isang mas bagong upstream na rebisyon.
Sa kasong ito, hindi kailangan ng bagong commit para iimbak ang pinagsamang kasaysayan; sa halip, ang ULO
(kasama ang index) ay ina-update upang tumuro sa pinangalanang commit, nang hindi gumagawa ng dagdag
merge commit.

Maaaring pigilan ang pag-uugaling ito gamit ang --no-ff na opsyon.

TRUE Sumanib

Maliban sa isang fast-forward merge (tingnan sa itaas), ang mga sanga na pagsasamahin ay dapat na itali
magkasama sa pamamagitan ng isang merge commit na pareho silang mga magulang.

Isang pinagsanib na bersyon na pinagkasundo ang mga pagbabago mula sa lahat ng mga sangay na isasama ay ginawa, at
ang iyong HEAD, index, at working tree ay na-update dito. Posibleng magkaroon ng mga pagbabago
sa working tree hangga't hindi sila magkakapatong; ang pag-update ay panatilihin ang mga ito.

Kapag hindi malinaw kung paano ipagkasundo ang mga pagbabago, ang mga sumusunod ay mangyayari:

1. Ang HEAD pointer ay nananatiling pareho.

2. Ang MERGE_HEAD ref ay nakatakdang tumuro sa kabilang branch head.

3. Ang mga landas na malinis na pinagsama ay ina-update pareho sa index file at sa iyong working tree.

4. Para sa magkasalungat na landas, ang index file ay nagtatala ng hanggang tatlong bersyon: ang yugto 1 ay nag-iimbak ng
bersyon mula sa karaniwang ninuno, yugto 2 mula sa HEAD, at yugto 3 mula sa MERGE_HEAD (ikaw
maaaring suriin ang mga yugto gamit ang git ls-files -u). Ang working tree file ay naglalaman ng
resulta ng "merge" na programa; ibig sabihin, ang mga resulta ng 3-way na pagsasanib sa mga pamilyar na marker ng salungatan
<<< === >>>.

5. Walang ibang pagbabagong ginawa. Sa partikular, ang mga lokal na pagbabago na nauna sa iyo
ang nagsimulang pagsasama ay mananatiling pareho at ang mga entry sa index para sa kanila ay mananatili sa dati,
ie tugmang HEAD.

Kung sinubukan mo ang isang pagsasanib na nagresulta sa mga kumplikadong salungatan at gustong magsimulang muli, magagawa mo
mabawi gamit ang git merge --abort.

PAGSASANIB TAG

Kapag pinagsasama ang isang annotated (at posibleng nilagdaan) na tag, palaging gumagawa ang Git ng merge commit
kahit na posible ang isang fast-forward merge, at ang template ng commit message ay inihanda kasama
ang mensahe ng tag. Bukod pa rito, kung ang tag ay nilagdaan, ang tseke ng lagda ay iuulat bilang a
magkomento sa template ng mensahe. Tingnan din git-tagNa (1).

Kapag gusto mong isama na lang sa gawaing humahantong sa commit na mangyayari
naka-tag, hal. pag-synchronize sa isang upstream release point, maaaring hindi mo gustong gumawa ng isang
hindi kinakailangang merge commit.

Sa ganoong sitwasyon, maaari mong "i-unwrap" ang tag sa iyong sarili bago ito i-feed sa git merge, o ipasa
--ff-lamang kapag wala kang anumang gawain sa iyong sarili. hal

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

PAANO MGA SAMAHAN MGA IPINAGPILALA

Sa panahon ng pagsasanib, ina-update ang gumaganang mga file ng puno upang ipakita ang resulta ng pagsasanib.
Kabilang sa mga pagbabagong ginawa sa bersyon ng karaniwang ninuno, ang mga hindi magkakapatong (iyon ay,
binago mo ang isang lugar ng file habang iniwan ng kabilang panig ang bahaging iyon nang buo, o kabaliktaran)
ay isinama sa huling resulta ng verbatim. Kapag ang magkabilang panig ay gumawa ng mga pagbabago sa pareho
lugar, gayunpaman, hindi maaaring random na pumili ang Git ng isang panig sa kabila, at hinihiling sa iyo na lutasin
ito sa pamamagitan ng pag-iwan sa ginawa ng magkabilang panig sa lugar na iyon.

Bilang default, ang Git ay gumagamit ng parehong istilo gaya ng ginamit ng "merge" program mula sa RCS
suite upang ipakita ang isang magkasalungat na hunk, tulad nito:

Narito ang mga linyang hindi nagbabago mula sa karaniwan
ninuno, o malinis na nalutas dahil isang panig lamang ang nagbago.
<<<<<<<< sa iyo:sample.txt
Mahirap ang paglutas ng salungatan;
Mag-shopping tayo.
=======
Ginagawang madali ng Git ang paglutas ng salungatan.
>>>>>>> kanila:sample.txt
At narito ang isa pang linya na malinis na nalutas o hindi binago.

Ang lugar kung saan nangyari ang isang pares ng magkasalungat na pagbabago ay minarkahan ng mga marker <<<<<<<,
=======, at >>>>>>>. Ang bahagi bago ang ======= ay karaniwang iyong panig, at ang bahagi
pagkatapos ay karaniwang ang kanilang panig.

Hindi ipinapakita ng default na format kung ano ang sinabi ng orihinal sa magkasalungat na lugar. Ikaw
hindi masasabi kung ilang linya ang tinanggal at pinalitan ng komento ni Barbie sa iyong panig. Ang
Ang tanging masasabi mo lang ay gustong sabihin ng iyong panig na mahirap ito at mas gugustuhin mong pumunta
shopping, habang ang kabilang panig ay gustong i-claim ito ay madali.

Maaaring gumamit ng alternatibong istilo sa pamamagitan ng pagtatakda ng configuration na "merge.conflictStyle."
variable sa "diff3". Sa istilong "diff3", ang salungatan sa itaas ay maaaring magmukhang ganito:

Narito ang mga linyang hindi nagbabago mula sa karaniwan
ninuno, o malinis na nalutas dahil isang panig lamang ang nagbago.
<<<<<<<< sa iyo:sample.txt
Mahirap ang paglutas ng salungatan;
Mag-shopping tayo.
||||||
Mahirap ang paglutas ng salungatan.
=======
Ginagawang madali ng Git ang paglutas ng salungatan.
>>>>>>> kanila:sample.txt
At narito ang isa pang linya na malinis na nalutas o hindi binago.

Bilang karagdagan sa <<<<<<<, =======, at >>>>>>> na mga marker, gumagamit ito ng isa pang ||||||| pananda
na sinusundan ng orihinal na teksto. Maaari mong sabihin na ang orihinal ay nagpahayag lamang ng isang katotohanan,
at ang iyong panig ay sumuko na lamang sa pahayag na iyon at sumuko, habang sinubukan ng kabilang panig
magkaroon ng mas positibong saloobin. Maaari kang makabuo kung minsan ng isang mas mahusay na resolusyon sa pamamagitan ng
tinitingnan ang orihinal.

PAANO SA I-RESOLVE MGA SAMAHAN

Pagkatapos makakita ng salungatan, magagawa mo ang dalawang bagay:

· Magpasya na huwag pagsamahin. Ang tanging paglilinis na kailangan mo ay i-reset ang index file sa
HEAD commit to reverse 2. and to clean up working tree changes made by 2. and 3.; git
merge --abort ay maaaring gamitin para dito.

· Resolbahin ang mga salungatan. Markahan ng Git ang mga salungatan sa working tree. I-edit ang mga file
sa hugis at pumunta idagdag sila sa index. Gamitin pumunta gumawa para selyuhan ang deal.

Maaari mong lutasin ang salungatan gamit ang ilang mga tool:

· Gumamit ng mergetool. git mergetool upang ilunsad ang isang graphical mergetool na gagana sa iyo
sa pamamagitan ng pagsasanib.

· Tingnan ang mga pagkakaiba. Ang git diff ay magpapakita ng isang three-way diff, na nagha-highlight ng mga pagbabago mula sa
parehong bersyon ng HEAD at MERGE_HEAD.

· Tingnan ang mga pagkakaiba mula sa bawat sangay. git log --merge -p magpapakita muna ng diffs
para sa bersyon ng HEAD at pagkatapos ay ang bersyon ng MERGE_HEAD.

· Tingnan ang mga orihinal. git show :1:filename ay nagpapakita ng karaniwang ninuno, git show
:2:filename ay nagpapakita ng HEAD na bersyon, at git show :3:filename ay nagpapakita ng MERGE_HEAD
bersyon.

HALIMBAWA

· Pagsamahin ang mga pag-aayos at pagpapahusay ng mga sangay sa ibabaw ng kasalukuyang sangay, na ginagawang isang octopus
pagsamahin:

Inaayos ng $ git merge ang mga pagpapahusay

· Pagsamahin ang sangay na hindi na ginagamit sa kasalukuyang sangay, gamit ang aming diskarte sa pagsasanib:

$ git merge -s atin ang hindi na ginagamit

· Pagsamahin ang branch maint sa kasalukuyang branch, ngunit huwag gumawa ng bagong commit
awtomatikong:

$ git merge --no-commit maint

Magagamit ito kapag gusto mong isama ang mga karagdagang pagbabago sa pagsasanib, o gusto mo
isulat ang iyong sariling merge commit message.

Dapat mong iwasang abusuhin ang opsyong ito para mag-sneak ng malalaking pagbabago sa isang merge
mangako. Ang maliliit na pag-aayos tulad ng bumping release/pangalan ng bersyon ay magiging katanggap-tanggap.

Sumanib ESTRATEHIYA

Ang mekanismo ng merge (git merge at git pull command) ay nagbibigay-daan sa backend pagsamahin estratehiya
na pipiliin gamit ang -s na opsyon. Ang ilang mga diskarte ay maaari ring kumuha ng kanilang sariling mga pagpipilian, na maaaring
naipasa sa pamamagitan ng pagbibigay -X mga argumento sa git merge at/o git pull.

malulutas nito
Maaari lamang nitong lutasin ang dalawang ulo (ibig sabihin, ang kasalukuyang sangay at isa pang sangay na iyong hinila
mula sa) gamit ang isang 3-way merge algorithm. Sinusubukan nitong maingat na tuklasin ang criss-cross merge
mga kalabuan at itinuturing na ligtas at mabilis.

recursive
Maaari lamang nitong lutasin ang dalawang ulo gamit ang isang 3-way merge algorithm. Kapag mayroong higit sa
isang karaniwang ninuno na maaaring gamitin para sa 3-way na pagsasanib, lumilikha ito ng pinagsanib na puno ng
karaniwang mga ninuno at ginagamit iyon bilang reference tree para sa 3-way merge. Ito ay
naiulat na magreresulta sa mas kaunting mga salungatan sa pagsasanib nang hindi nagdudulot ng mga mismerge sa pamamagitan ng mga pagsubok
tapos na sa aktwal na merge commits na kinuha mula sa Linux 2.6 kernel development history.
Bukod pa rito, maaari nitong makita at mahawakan ang mga pagsasanib na kinasasangkutan ng mga pagpapalit ng pangalan. Ito ang default
pagsamahin ang diskarte kapag hinihila o pinagsasama ang isang sangay.

Ang recursive ang diskarte ay maaaring kumuha ng mga sumusunod na opsyon:

magsilang ng sanggol
Pinipilit ng opsyong ito ang magkasalungat na hunks na awtomatikong malutas nang malinis sa pamamagitan ng pag-favor natin
bersyon. Ang mga pagbabago mula sa kabilang puno na hindi sumasalungat sa ating panig ay
ipinapakita sa resulta ng pagsasanib. Para sa isang binary file, ang buong nilalaman ay kinuha
mula sa aming panig.

Hindi ito dapat malito sa magsilang ng sanggol pagsamahin ang diskarte, na hindi kahit na tumingin
sa kung ano ang nilalaman ng iba pang puno. Itinatapon nito ang lahat ng ginawa ng ibang puno,
deklarasyon natin ang kasaysayan ay naglalaman ng lahat ng nangyari dito.

kanila
Ito ang kabaligtaran ng magsilang ng sanggol.

pagtitiyaga
Sa pagpipiliang ito, merge-recursive gumugugol ng kaunting dagdag na oras upang maiwasan ang mga mismerge
na kung minsan ay nangyayari dahil sa hindi mahalagang pagtutugma ng mga linya (hal., mga braces mula sa distinct
mga function). Gamitin ito kapag ang mga sanga na pagsasamahin ay naghiwalay nang husto. Tingnan din
git-diff(1) --pasensya.

diff-algorithm=[patience|minimal|histogram|myers]
Sinasabi merge-recursive gumamit ng ibang diff algorithm, na makakatulong sa pag-iwas
mga mismerge na nangyayari dahil sa hindi mahalagang pagtutugma ng mga linya (tulad ng mga braces mula sa
natatanging mga pag-andar). Tingnan din git-diff(1) --diff-algorithm.

ignore-space-change, ignore-all-space, ignore-space-at-eol
Tinatrato ang mga linya na may ipinahiwatig na uri ng pagbabago ng whitespace bilang hindi nagbabago para sa
alang-alang sa isang three-way merge. Ang mga pagbabago sa whitespace ay may halong iba pang mga pagbabago sa isang linya
ay hindi pinapansin. Tingnan din git-diff(1) -b, -w, at --ignore-space-at-eol.

· Kung Russia at ilang bansa sa Asya. ang bersyon ay nagpapakilala lamang ng mga pagbabago sa whitespace sa isang linya, natin bersyon ay
ginamit;

· Kung natin ang bersyon ay nagpapakilala ng mga pagbabago sa whitespace ngunit Russia at ilang bansa sa Asya. bersyon ay may kasamang a
malaking pagbabago, Russia at ilang bansa sa Asya. ginagamit ang bersyon;

· Kung hindi, ang pagsasanib ay magpapatuloy sa karaniwang paraan.

gawing normal muli
Ito ay nagpapatakbo ng isang virtual na check-out at check-in ng lahat ng tatlong yugto ng isang file kapag
paglutas ng three-way merge. Ang opsyon na ito ay nilalayong gamitin kapag pinagsasama ang mga sanga
na may iba't ibang malinis na filter o end-of-line na mga panuntunan sa normalisasyon. Tingnan ang "Pagsasama-sama
mga sangay na may magkakaibang katangian ng checkin/checkout" sa gitattributes(5) para sa
mga detalye.

no-renormalize
Hindi pinapagana ang opsyon sa renormalize. Ino-override nito ang merge.renormalize
variable ng pagsasaayos.

rename-threshold=
Kinokontrol ang threshold ng pagkakatulad na ginagamit para sa pagtuklas ng palitan ng pangalan. Tingnan din git-diff(1)
-M.

subtree[= ]
Ang pagpipiliang ito ay isang mas advanced na anyo ng subtree diskarte, kung saan gumagawa ang diskarte
isang hula kung paano dapat ilipat ang dalawang puno upang tumugma sa isa't isa kapag nagsasama.
Sa halip, ang tinukoy na landas ay naka-prefix (o hinubad mula sa simula) upang gawin
ang hugis ng dalawang puno na magkatugma.

pugita
Niresolba nito ang mga kaso na may higit sa dalawang ulo, ngunit tumangging gumawa ng isang kumplikadong pagsamahin iyon
nangangailangan ng manu-manong resolusyon. Pangunahing nilayon itong gamitin para sa pag-bundling ng sangay ng paksa
magkakasama ang ulo. Ito ang default na diskarte sa pagsasama kapag kumukuha o nagsasama ng higit sa
isang sangay.

magsilang ng sanggol
Niresolba nito ang anumang bilang ng mga ulo, ngunit ang resultang puno ng pagsasanib ay palaging iyon
ng kasalukuyang pinuno ng sangay, na epektibong binabalewala ang lahat ng pagbabago mula sa lahat ng iba pang sangay.
Ito ay nilalayong gamitin upang palitan ang lumang kasaysayan ng pag-unlad ng mga sanga sa gilid. Tandaan
na ito ay iba sa -Xours na opsyon sa recursive pagsamahin ang diskarte.

subtree
Ito ay isang binagong recursive na diskarte. Kapag pinagsasama ang mga puno A at B, kung ang B ay tumutugma sa
isang subtree ng A, B ay unang inaayos upang tumugma sa istraktura ng puno ng A, sa halip na
pagbabasa ng mga puno sa parehong antas. Ang pagsasaayos na ito ay ginagawa din sa karaniwan
puno ng ninuno.

Gamit ang mga diskarte na gumagamit ng 3-way merge (kabilang ang default, recursive), kung may pagbabago
ay ginawa sa parehong mga sangay, ngunit sa paglaon ay ibinalik sa isa sa mga sangay, ang pagbabagong iyon ay magiging
naroroon sa pinagsamang resulta; nakakalito ang pag-uugali ng ilang tao. Nangyayari ito dahil
tanging ang mga ulo at ang merge base ang isinasaalang-alang kapag nagsasagawa ng isang merge, hindi ang
ginagawa ng indibidwal. Samakatuwid, isinasaalang-alang ng merge algorithm ang ibinalik na pagbabago bilang hindi
baguhin sa lahat, at pinapalitan ang binagong bersyon sa halip.

Configuration

merge.conflictStyle
Tukuyin ang istilo kung saan isinusulat ang mga magkasalungat na hunks sa gumaganang mga file ng puno
pagsamahin. Ang default ay "merge", na nagpapakita ng <<<<<<< conflict marker, mga pagbabagong ginawa ni
isang gilid, isang ======= marker, mga pagbabagong ginawa ng kabilang panig, at pagkatapos ay isang >>>>>>> marker.
Ang kahaliling istilo, "diff3", ay nagdaragdag ng ||||||| marker at ang orihinal na teksto bago ang
======= pananda.

merge.defaultToUpstream
Kung ang merge ay tinatawag na walang anumang commit argument, pagsamahin ang upstream branch na na-configure
para sa kasalukuyang sangay sa pamamagitan ng paggamit ng kanilang huling naobserbahang mga halaga na nakaimbak sa kanilang
mga sangay ng remote-tracking. Ang mga halaga ng sangay. .pagsamahin ang pangalang iyon
ang mga sangay sa remote na pinangalanan ng sangay. .remote ay kinonsulta, at
pagkatapos ay nakamapa sila sa pamamagitan ng remote. .fetch sa kanilang kaukulang remote-tracking
mga sanga, at ang mga tip ng mga sanga sa pagsubaybay na ito ay pinagsama.

pagsamahin.ff
Bilang default, hindi gumagawa ang Git ng dagdag na merge commit kapag pinagsasama ang isang commit na a
descendant ng kasalukuyang commit. Sa halip, ang dulo ng kasalukuyang sangay ay
fast-forwarded. Kapag nakatakda sa false, ang variable na ito ay nagsasabi sa Git na gumawa ng karagdagang pagsasama
commit sa ganoong kaso (katumbas ng pagbibigay ng --no-ff na opsyon mula sa command line).
Kapag nakatakda sa lamang, ang mga ganoong fast-forward merge lang ang pinapayagan (katumbas ng pagbibigay ng
--ff-only na opsyon mula sa command line).

pagsamahin.branchdesc
Bilang karagdagan sa mga pangalan ng sangay, punan ang mensahe ng log ng teksto ng paglalarawan ng sangay
nauugnay sa kanila. Default sa false.

merge.log
Bilang karagdagan sa mga pangalan ng sangay, punan ang mensahe ng log ng hindi hihigit sa tinukoy
bilang ng isang linyang paglalarawan mula sa mga aktwal na commit na pinagsasama.
Default sa false, at true ay kasingkahulugan ng 20.

merge.renameLimit
Ang bilang ng mga file na dapat isaalang-alang kapag nagsasagawa ng rename detection sa panahon ng isang pagsasanib; kung
hindi tinukoy, default sa halaga ng diff.renameLimit.

pagsamahin.renormalize
Sabihin kay Git na ang canonical na representasyon ng mga file sa repositoryo ay nagbago na
oras (hal. naunang gumawa ng mga record text file na may CRLF line endings, ngunit kamakailan lamang
gumamit ng LF line endings). Sa naturang repositoryo, maaaring i-convert ng Git ang data na naitala sa
commits sa isang canonical form bago magsagawa ng isang merge upang mabawasan ang mga hindi kinakailangang salungatan.
Para sa karagdagang impormasyon, tingnan ang seksyong "Pagsasama-sama ng mga sangay na may magkakaibang checkin/checkout
mga katangian" sa gitattributesNa (5).

merge.stat
Kung ipi-print ang diffstat sa pagitan ng ORIG_HEAD at ng resulta ng pagsasanib sa dulo ng
pagsamahin. Totoo bilang default.

merge.tool
Kinokontrol kung aling merge tool ang ginagamit ng git-mergetool(1). Ang listahan sa ibaba ay nagpapakita ng wasto
built-in na mga halaga. Anumang iba pang halaga ay itinuturing bilang isang custom na tool sa pagsasama at nangangailangan na a
kaukulang mergetool. .cmd variable ay tinukoy.

· araxis

· bc

· bc3

· codecompare

· deltawaker

· diffmerge

· nagkakalat

· lumabas

· lumabas

· gvimdiff

· gvimdiff2

· gvimdiff3

· kdiff3

· maghalo

· opendiff

· p4merge

· tkdiff

· pagsibol ng pagong

· vimdiff

· vimdiff2

· vimdiff3

· winmerge

· xxdiff

merge.verbosity
Kinokontrol ang dami ng output na ipinapakita ng recursive merge na diskarte. Level 0 na mga output
wala maliban sa isang huling mensahe ng error kung may nakitang mga salungatan. Level 1 na mga output lang
mga salungatan, 2 mga salungatan sa output at mga pagbabago sa file. Level 5 at mas mataas ay nagde-debug ng mga output
impormasyon. Ang default ay level 2. Maaaring ma-override ng GIT_MERGE_VERBOSITY
variable ng kapaligiran.

pagsamahin. .pangalan
Tinutukoy ang isang pangalan na nababasa ng tao para sa isang custom na low-level merge driver. Tingnan mo
gitattributes(5) para sa mga detalye.

pagsamahin. .driver
Tinutukoy ang command na nagpapatupad ng custom na low-level merge driver. Tingnan mo
gitattributes(5) para sa mga detalye.

pagsamahin. .recursive
Pangalanan ang isang mababang antas na merge driver na gagamitin kapag nagsasagawa ng internal merge sa pagitan
karaniwang mga ninuno. Tingnan mo gitattributes(5) para sa mga detalye.

sangay. .mergeOptions
Nagtatakda ng mga default na opsyon para sa pagsasama sa sangay . Ang syntax at mga suportadong opsyon
ay pareho sa mga ng pumunta pagsamahin, ngunit mga value ng opsyon na naglalaman ng mga character na whitespace
ay kasalukuyang hindi suportado.

Gumamit ng git-merge online gamit ang mga serbisyo ng onworks.net