Paano Gamitin ang Git merge


Buod: Upang pagsamahin ang isang development branch sa kasalukuyang branch, gamitin ang git merge dev-branch-name. Kung nakakakuha ka ng mga babala ng salungatan tungkol sa isang merge, gamitin ang git merge --abort upang i-back out ito, o i-edit ang mga apektadong file at pagkatapos ay i-commit ang mga ito.

Gumagamit ang Git ng mga branch para ihiwalay ang mga development stream, para maiwasang maging polluted ang stable na release branch. Ang pagdadala ng trabaho sa isang sangay sa pangunahing stream ay nangangahulugan ng pagsasama-sama ng mga sangay. Narito kung paano mo ito gagawin.

Ano ang isang Pagsamahin sa Git?

Ang Git ay idinisenyo upang gawing simple at mabilis ang pagsasanga. Sa kaibahan sa ibang mga version control system, ang pagsasanga sa Git ay isang maliit na bagay. Sa mga multi-developer na proyekto lalo na, ang pagsasanga ay isa sa mga pangunahing tool sa organisasyon ng Git.

Mga branch sa sandbox ng mga bagong pagsisikap sa pag-unlad upang ang code ay maaaring mabago o maidagdag nang hindi naaapektuhan ang code sa ibang mga sangay, lalo na ang pangunahing o master branch. Karaniwang naglalaman ito ng stable na bersyon ng iyong code base.

Ang paghihiwalay ng mga pagbabagong ito mula sa iyong stable na bersyon ng code ay may perpektong kahulugan. Ngunit sa lalong madaling panahon ang bagong code ay susuriin, susuriin, at tatakan ng goma upang i-roll sa master branch. Sa puntong iyon, kailangan mong pagsamahin ang iyong sangay sa master branch.

Sa totoo lang, maaaring magkaroon ng mga sub-branch ang mga branch kaya maaaring isama mo ang iyong branch sa ibang branch sa halip na master branch. Tandaan lamang na ang mga pagsasanib ay palaging kumukuha ng isang sangay at pinagsama ito sa isang target sangay, anuman ang sangay na iyon. Kung gusto mong pagsamahin ang iyong master branch sa isa pang branch, magagawa mo rin iyon.

Tulad ng karamihan sa mga aksyon sa Git, nagsasagawa ka ng mga pagsasanib sa iyong lokal na imbakan at itulak ang mga ito sa iyong malayong imbakan.

Paghahanda na Pagsamahin ang isang Sangay sa Git

Mayroon kaming maliit na proyekto sa pag-unlad na may lokal na Git repository at isang remote na Git repository. Gumawa kami ng branch na tinatawag na bugfix14 mula sa master branch at gumawa ng solusyon sa isang bug.

Nakumpleto na ang gawaing iyon, at sinubukan namin ang aming code. Gumagana ang lahat tulad ng inaasahan. Gusto naming i-roll ang mga pagbabagong iyon sa master branch upang ang aming pag-aayos ay bahagi ng susunod na release ng software.

May kaunting paghahandang dapat gawin bago namin isagawa ang pagsasanib. Kailangan nating tiyakin na ang target na sangay—sa kasong ito ang master na sangay—at ang sangay na pagsasamahin natin dito ay parehong napapanahon.

Upang gawin ito, gagamitin namin ang command na git status.

git status

  • Sa branch bugfix14: Ito ang aming kasalukuyang branch.
  • Ang iyong sangay ay napapanahon sa 'pinagmulan/pag-aayos ng bug': Ang sangay sa aming lokal na imbakan ay may parehong kasaysayan ng commit gaya ng sangay sa malayong imbakan. Ibig sabihin, magkapareho sila.
  • walang gagawin Walang mga pagbabago sa lugar ng pagtatanghal na hindi pa nagagawa.
  • nagtatrabahong punong malinis: Walang mga hindi naka-stage na pagbabago sa gumaganang direktoryo.

Ang lahat ng iyon ay nagpapahiwatig na ang sangay ay napapanahon, at malinaw kaming magpatuloy. Kung alinman sa mga ito ang nagsasaad na may mga pagbabago, kailangan nating i-stage ang mga ito, i-commit ang mga ito, at itulak ang mga ito sa remote. Kung may ibang tao na gumawa sa mga file na ito, maaaring kailanganin nating kunin ang kanilang mga pagbabago mula sa malayong repositoryo.

Ang pagsuri sa sangay na pagsasamahin natin ay pinapasimple ang proseso ng pagsasama. Nagbibigay-daan din ito sa amin na i-verify na napapanahon ito. Tingnan natin ang master branch.

git checkout master
git status

Nakukuha namin ang parehong mga kumpirmasyon na ang master na sangay ay napapanahon.

Nagsasagawa ng Pagsasama

Bago tayo magsama, ganito ang hitsura ng ating mga commit.

Ang sangay ng bugfix14 ay nagsanga mula sa sangay ng master. Nagkaroon ng commit sa master branch pagkatapos malikha ang bugfix14 branch. Nagkaroon ng ilang commit sa bugfix14 branch.

Natiyak naming napapanahon ang aming dalawang sangay, at nasuri na namin ang sangay na master. Maaari kaming mag-isyu ng command na pagsamahin ang bugfix14 na sangay sa master na sangay.

git merge bugfix14

Nagaganap ang pagsasanib. Umiiral pa rin ang bugfix14 branch, ngunit ngayon ang mga pagbabagong ginawa sa branch na iyon ay pinagsama sa master branch.

Sa pagkakataong ito, nagsasagawa ang merge command ng three-way merge. Dalawa lang ang branch, pero may tatlong commit na kasali. Sila ang pinuno ng alinmang sangay, at ang pangatlong commit na kumakatawan sa mismong pagkilos ng pagsasanib.

Upang i-update ang aming malayuang imbakan, maaari naming gamitin ang command na git push.

git push

Mas gusto ng ilang tao na tanggalin ang mga side branch kapag pinagsama na nila ang mga ito. Ang iba ay nag-iingat upang mapanatili ang mga ito bilang isang talaan ng tunay na kasaysayan ng pag-unlad ng proyekto.

Kung gusto mong tanggalin ang branch, magagawa mo ito gamit ang command na git branch na may opsyon na -d (delete).

git branch -d bugfix14

Upang tanggalin ang sangay sa malayong imbakan, gamitin ang utos na ito:

git push origin --delete bugfix14

Magkakaroon ka ng linear commit history, ngunit hindi ito ang tunay na history.

Pagsasagawa ng Fast-Forward Merge sa Git

Kung hindi ka pa gumawa ng anumang commit sa master branch, magiging ganito ang iyong history. Ito rin ang titingnan kung na-rebase mo ang iyong development branch para ito ay naka-attach sa dulo ng master na branch.

Dahil walang mga commit sa master branch, para pagsamahin ang bugfix15 branch, ang kailangan lang gawin ng Git ay ituro ang master head pointer sa huling commit ng bugfix15 branch.

Magagamit natin ang karaniwang git merge command:

git merge bugfix15

Iyon ay nagbibigay sa amin ng resultang ito.

Alin ang kapareho nito:

Na kapareho lang nito:

Magsasagawa ang Git ng fast-forward merge kahit kailan kaya nito. Kung ang pag-commit sa master na sangay ay nangangahulugang hindi posible ang fast-forward merge, gagamit ang Git ng three-way merge.

Hindi mo maaaring puwersa ang isang fast-forward na pagsasama—maaaring hindi ito posible, pagkatapos ng lahat—ngunit maaari mong ipahayag na ito ay magiging fast-forward merge o wala. May isang opsyon na nagtuturo sa Git na gumamit ng fast-forward merge kung kaya nito, ngunit huwag gumawa ng three-way merge kung hindi nito magagawa. Ang opsyon ay --ff-only (fast-forward merge lang).

Pinagsasama nito ang sangay ng bugfix15 sa sangay ng master, ngunit kung posible lamang ang isang fast-forward na pagsasama.

git merge --ff-only bugfix15

Magrereklamo at lalabas si Git kung hindi ito posible.

git merge --ff-only bugfix16

Sa kasong ito, nagkaroon ng commit sa master branch, kaya hindi posible ang fast-forward merge.

Paano Lutasin ang Mga Salungatan sa Pagsamahin sa Git

Kung ang parehong mga bahagi ng parehong file ay binago sa parehong mga sangay, ang mga sangay ay hindi maaaring pagsamahin. Ang pakikipag-ugnayan ng tao ay kinakailangan upang malutas ang magkasalungat na mga pag-edit.

Dito, nakagawa kami ng mga pagbabago sa isang file na tinatawag na rot.c sa isang branch na tinatawag na bugfix17 na gusto naming pagsamahin sa master na branch. Ngunit ang rot.c ay binago din sa master na sangay.

git merge bugfix17

Kapag sinubukan naming pagsamahin ito, nakakakuha kami ng babala na may mga salungatan. Inililista ng Git ang mga magkasalungat na file, at sinasabi sa amin na nabigo ang pagsasanib. Maaari kaming ganap na mag-back out gamit ang --abort na opsyon:

git merge --abort

Ngunit ang paglutas ng mga pagsasanib ay hindi nakakatakot gaya ng sinasabi nito. Ang Git ay gumawa ng ilang gawain upang matulungan kami. Kung mag-e-edit kami ng isa sa mga magkasalungat na file—sa aming kaso, isa lang ang mayroon kami—makikita namin ang magkasalungat na mga seksyon ng code na naka-highlight para sa amin.

Ang bawat salungatan ay nililimitahan ng pitong mas mababa kaysa sa mga character na <<<<<<< at pitong mas mataas kaysa sa mga character na >>>>>>>, na may pitong katumbas ng mga palatandaang “=======” sa pagitan nila.

  • Ang code sa itaas ng mga katumbas na palatandaan ay mula sa sangay na pinagsasama-sama mo sa.
  • Ang code sa ibaba ng equals sign ay ang code mula sa branch na sinusubukan mong pagsamahin.

Madali kang makakahanap ng isa sa mga set ng pitong character at lumipat mula sa conflict patungo sa conflict sa pamamagitan ng iyong file. Para sa bawat salungatan, kailangan mong piliin kung aling hanay ng mga pag-edit ang pananatilihin mo. Dapat mong i-edit ang code na iyong tinatanggihan, at ang pitong character na linya na idinagdag ni Git.

Itatago namin ang code sa sangay na bugfix17. Pagkatapos mag-edit, ganito ang hitsura ng aming file.

Maaari na tayong magpatuloy sa pagsasanib. Ngunit tandaan, ginagamit namin ang command na commit para gawin ito, hindi ang command na merge.

Ginagawa namin ang pagbabago sa pamamagitan ng pagtatanghal ng file at ginagawa ito gaya ng dati. Susuriin namin ang status bago namin gawin ang panghuling commit.

git add rot.c
git status
git commit -m "Merged bugfix17"

Kumpleto na ang pagsasanib. Maaari na naming itulak ito sa aming malayong imbakan.

Ang Lahat ay Nagsasama Sa Paglaon

Ang lahat ng mga sangay ay kailangang pagsamahin, sa huli, upang ang mga pagbabago sa kanila ay hindi maulila at makalimutan.

Ang pagsasama-sama ng mga sangay ay madali, ngunit ang pagharap sa mga salungatan ay maaaring maging kumplikado sa abala, mas malalaking koponan. Ang paglutas ng mga salungatan ay maaaring mangailangan ng input mula sa bawat developer para lang ipaliwanag kung ano ang ginagawa ng kanilang code at kung bakit nila ginawa ang kanilang mga pagbabago. Kailangan mong maunawaan iyon, bago ka makagawa ng matalinong desisyon tungkol sa kung aling mga pag-edit ang dapat panatilihin.

Nakalulungkot, hindi makakatulong ang Git diyan.