Git හි ඒකාබද්ධ කිරීමේ ගැටුම් නිරාකරණය කරන්නේ කෙසේද?

උත්සාහ කරන්න: git mergetool

එය එක් එක් ගැටුම හරහා ඔබව ගෙන යන GUI එකක් විවෘත කරන අතර, ඔබ ඒකාබද්ධ වන්නේ කෙසේදැයි තෝරා ගත යුතුය. සමහර විට ඊට පසු අතින් සංස්කරණය කිරීම අවශ්‍ය වේ, නමුත් සාමාන්‍යයෙන් එය තනිවම ප්‍රමාණවත් වේ. නිසැකවම මුළු දේම අතින් කරනවාට වඩා හොඳය.

Os ජොෂ් ග්ලෝවර් අදහස් දැක්වීමට අනුව:

විධානය

ඔබ එකක් ස්ථාපනය නොකරන්නේ නම් අනිවාර්යයෙන්ම GUI එකක් විවෘත නොකරයි. git mergetoolමා වෙනුවෙන් ධාවනය කිරීමෙන් ප්‍රති vimdiffused ල ලැබුණි . ඔබට ඒ වෙනුවට එය භාවිතා කිරීමට පහත සඳහන් මෙවලම් එකක් ස්ථාපනය කළ හැක: meld, opendiff, kdiff3, tkdiff, xxdiff, tortoisemerge, gvimdiff, diffuse, ecmerge, p4merge, araxis, vimdiff, emerge.

vimdiffඒකාබද්ධ කිරීමේ ගැටුම් නිරාකරණය සඳහා භාවිතා කළ යුතු නියැදි ක්‍රියා පටිපාටිය පහත දැක්වේ . මෙම සබැඳිය මත පදනම්ව

පියවර 1 : ඔබේ ටර්මිනලයේ පහත විධානයන් ක්‍රියාත්මක කරන්න

git config merge.tool vimdiff
git config merge.conflictstyle diff3
git config mergetool.prompt false

මෙය පෙරනිමි ඒකාබද්ධ කිරීමේ මෙවලම ලෙස vimdiff සකසනු ඇත.

පියවර 2 : ටර්මිනලයේ පහත විධානය ක්‍රියාත්මක කරන්න

git mergetool

පියවර 3 : පහත දැක්වෙන ආකෘතියෙන් ඔබට විම්ඩිෆ් සංදර්ශනයක් පෙනෙනු ඇත

  ╔═══════╦══════╦════════╗
  ║       ║      ║        ║
  ║ LOCAL ║ BASE ║ REMOTE ║
  ║       ║      ║        ║
  ╠═══════╩══════╩════════╣
  ║                       ║
  ║        MERGED         ║
  ║                       ║
  ╚═══════════════════════╝

මෙම අදහස් 4 වේ

LOCAL - මෙය වත්මන් ශාඛාවේ ගොනුවකි

BASE - පොදු මුතුන් මිත්තෙකු, වෙනස්කම් දෙකටම පෙර ගොනුව බැලූ ආකාරය

ඉවත් කරන්න - ඔබ ඔබේ ශාඛාවට ඒකාබද්ධ කරන ගොනුව

ඒකාබද්ධ - ප්‍රති result ලය ඒකාබද්ධ කරන්න, මෙය repo හි ඉතිරි වේ

ඔබට ctrl+ භාවිතා කර මෙම අදහස් අතර සැරිසැරීමට හැකිය w. ctrl+ wඅනුගමනය කිරීමෙන් ඔබට කෙලින්ම MERGED දර්ශනය වෙත ළඟා විය හැකිය j.

විම්ඩිෆ් සංචලනය පිළිබඳ වැඩි විස්තර මෙතැනින් සහ මෙතැනින්

පියවර 4 . ඔබට MERGED දර්ශනය පහත පරිදි සංස්කරණය කළ හැකිය

ඔබට REMOTE වෙතින් වෙනස්කම් ලබා ගැනීමට අවශ්‍ය නම්

:diffg RE  

ඔබට BASE වෙතින් වෙනස්කම් ලබා ගැනීමට අවශ්‍ය නම්

:diffg BA  

ඔබට LOCAL වෙතින් වෙනස්කම් ලබා ගැනීමට අවශ්‍ය නම්

:diffg LO 

පියවර 5 . සුරකින්න, පිටවන්න, කැප වන්න සහ පිරිසිදු කරන්න

:wqa vi වෙතින් සුරකින්න සහ පිටවන්න

git commit -m "message"

git clean වෙනස මෙවලම මඟින් සාදන ලද අතිරේක ලිපිගොනු (උදා: * .orig) ඉවත් කරන්න.

ඉහළ සිට භාවිතා කළ හැකි භාවිත අවස්ථාවක් මෙන්න:

ඔබ යම් යම් වෙනස්කම් කිරීමට යන්නේ, නමුත් අපොයි, ඔබ යාවත්කාලීන නොවේ:

git fetch origin
git pull origin master

From ssh://gitosis@example.com:22/projectname
 * branch            master     -> FETCH_HEAD
Updating a030c3a..ee25213
error: Entry 'filename.c' not uptodate. Cannot merge.

එබැවින් ඔබ යාවත්කාලීන වී නැවත උත්සාහ කරන්න, නමුත් ගැටුමක් ඇති කරන්න:

git add filename.c
git commit -m "made some wild and crazy changes"
git pull origin master

From ssh://gitosis@example.com: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.

එබැවින් වෙනස්කම් දෙස බැලීමට ඔබ තීරණය කරයි:

git mergetool

ඔහ්, ඔහ්, උඩුමහලේ සමහර දේවල් වෙනස් විය, නමුත් මගේ වෙනස්කම් භාවිතා කිරීමට ... නැත ... ඒවායේ වෙනස්කම් ...

git checkout --ours filename.c
git checkout --theirs filename.c
git add filename.c
git commit -m "using theirs"

ඊට පස්සේ අපි අවසාන වතාවට උත්සාහ කරමු

git pull origin master

From ssh://gitosis@example.com:22/projectname
 * branch            master     -> FETCH_HEAD
Already up-to-date.

තා-ඩා!

ඒකාබද්ධ කිරීමේ මෙවලම් ගැටුම හෝ විසඳුම තේරුම් ගැනීමට මට උදව් කරන්නේ කලාතුරකිනි. මම සාමාන්‍යයෙන් වඩා සාර්ථක වන්නේ පෙළ සංස්කාරකයක ගැටුම් සලකුණු දෙස බැලීම සහ අතිරේකයක් ලෙස git ලොග් භාවිතා කිරීමයි.

මෙන්න උපදෙස් කිහිපයක්:

ඉඟිය

මා සොයාගෙන ඇති හොඳම දේ වන්නේ "diff3" ඒකාබද්ධ කිරීමේ ගැටුම් විලාසය භාවිතා කිරීමයි:

git config merge.conflictstyle diff3

මෙය මෙවැනි ගැටුම් සලකුණු නිපදවයි:

<<<<<<<
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.
>>>>>>>

මැද කොටස යනු පොදු මුතුන් මිත්තන්ගේ පෙනුමයි. මෙය ප්‍රයෝජනවත් වන්නේ එක් එක් ශාඛාවේ වෙනස් කර ඇති දේ පිළිබඳ වඩා හොඳ අවබෝධයක් ලබා ගැනීම සඳහා ඔබට එය ඉහළ සහ පහළ අනුවාද සමඟ සංසන්දනය කළ හැකි අතර, එමඟින් එක් එක් වෙනසෙහි අරමුණ කුමක්ද යන්න පිළිබඳව වඩා හොඳ අදහසක් ඔබට ලබා දෙයි.

ගැටුම පේළි කිහිපයක් පමණක් නම්, මෙය සාමාන්‍යයෙන් ගැටුම ඉතා පැහැදිලිව පෙනේ. . හිදී.)

ගැටුම දිගු නම්, මම එක් එක් කොටස් තුනම "මගේ", "පොදු" සහ "ඔවුන්ගේ" වැනි වෙනම ලිපිගොනු තුනකට කපා අලවන්නෙමි.

ගැටුමට හේතු වූ එකිනෙකට වෙනස් හන්ක් දෙක බැලීමට මට පහත විධානයන් ක්‍රියාත්මක කළ හැකිය:

diff common mine
diff common theirs

මෙය ඒකාබද්ධ කිරීමේ මෙවලමක් භාවිතා කිරීම හා සමාන නොවේ, මන්දයත් ඒකාබද්ධ කිරීමේ මෙවලමට ගැටුම් නොවන විවිධ හන්ක් ද ඇතුළත් වන බැවිනි. එය අවධානය වෙනතකට යොමු කිරීමක් ලෙස මට පෙනේ.

ඉඟිය දෙක

කවුරුහරි දැනටමත් මෙය සඳහන් කර ඇත, නමුත් ගැටුමක් ඇති වූයේ කොහෙන්ද සහ එය හැසිරවිය යුතු ආකාරය තේරුම් ගැනීමට එක් එක් වෙනස පිටුපස ඇති අභිප්‍රාය තේරුම් ගැනීම සාමාන්‍යයෙන් බෙහෙවින් උපකාරී වේ.

git log --merge -p <name of file>

පොදු මුතුන් මිත්තෙකු සහ ඔබ ඒකාබද්ධ කරන ප්‍රධානීන් දෙදෙනා අතර එම ගොනුව ස්පර්ශ කළ සියලු කැපවීම් මෙයින් පෙන්නුම් කෙරේ. (එබැවින් ඒකාබද්ධ වීමට පෙර ශාඛා දෙකෙහිම දැනටමත් පවතින කොමිස් එයට ඇතුළත් නොවේ.) මෙය ඔබගේ වර්තමාන ගැටුමට පැහැදිලිවම සාධකයක් නොවන වෙනස් හන්ක් නොසලකා හැරීමට උපකාරී වේ.

ඉඟිය තුන

ස්වයංක්‍රීය මෙවලම් සමඟ ඔබගේ වෙනස්කම් සත්‍යාපනය කරන්න.

ඔබට ස්වයංක්‍රීය පරීක්ෂණ තිබේ නම් ඒවා ක්‍රියාත්මක කරන්න. ඔබට ලින්ට් එකක් තිබේ නම් , එය ක්‍රියාත්මක කරන්න. එය ගොඩනගා ගත හැකි ව්‍යාපෘතියක් නම්, ඔබ එය කිරීමට පෙර එය ගොඩනඟන්න. ආදිය. සෑම අවස්ථාවකදීම, ඔබගේ වෙනස්වීම් කිසිවක් කැඩී නොයන බවට වග බලා ගැනීම සඳහා ඔබ ටිකක් පරීක්ෂා කිරීමක් කළ යුතුය. (හෙක්, ගැටුම් නොමැතිව ඒකාබද්ධ කිරීම පවා වැඩ කිරීමේ කේතය බිඳ දැමිය හැකිය.)

ඉඟිය හතර

ඉදිරි සැලසුම් කරන්න; සම සේවකයින් සමඟ සන්නිවේදනය කරන්න.

කල්තියා සැලසුම් කිරීම සහ අනෙක් අය ක්‍රියා කරන දේ පිළිබඳව දැනුවත්ව සිටීම ගැටුම් ඒකාබද්ධ කිරීම වළක්වා ගැනීමට සහ / හෝ කලින් විසඳීමට උපකාරී වේ - විස්තර තවමත් මතකයේ ඇත.

නිදසුනක් ලෙස, ඔබ සහ තවත් පුද්ගලයෙකු එකම ප්‍රතිස්ථාපන ක්‍රියාවලියක යෙදී සිටින බව ඔබ දන්නේ නම්, ඒ දෙකම එකම ලිපිගොනු සමූහයකට බලපානු ඇත, ඔබ කලින්ම එකිනෙකා සමඟ කතා කළ යුතු අතර ඔබ එක් එක් කුමන ආකාරයේ වෙනස්කම්ද යන්න පිළිබඳව වඩා හොඳ අවබෝධයක් ලබා ගත යුතුය. සෑදීම. ඔබ සැලසුම් කළ වෙනස්කම් සමාන්තරව නොව අනුක්‍රමිකව සිදු කරන්නේ නම් ඔබට සැලකිය යුතු කාලයක් හා ශ්‍රමයක් ඉතිරි කර ගත හැකිය.

කේත විශාල ප්‍රමාණයක් හරහා ගමන් කරන ප්‍රධාන ප්‍රතික්‍රියාකාරක සඳහා, ඔබ අනුක්‍රමිකව වැඩ කිරීම ගැන දැඩි ලෙස සලකා බැලිය යුතුය: සෑම කෙනෙකුම කේතයේ එම ප්‍රදේශය මත වැඩ කිරීම නවත්වන අතර එක් පුද්ගලයෙකු සම්පූර්ණ ප්‍රතිචක්‍රීකරණය සිදු කරයි.

ඔබට අනුක්‍රමිකව වැඩ කිරීමට නොහැකි නම් (කාල පීඩනය හේතුවෙන්, සමහර විට), එවිට අපේක්ෂිත ඒකාබද්ධ කිරීමේ ගැටුම් ගැන සන්නිවේදනය කිරීම අවම වශයෙන් තොරතුරු මනසෙහි නැවුම්ව තිබියදී ගැටළු ඉක්මනින් විසඳීමට උපකාරී වේ. නිදසුනක් වශයෙන්, සතියක කාලයක් තුළ සම-සේවකයෙකු කඩාකප්පල්කාරී ක්‍රියාකාරකම් මාලාවක් සිදු කරන්නේ නම්, එම සතිය තුළ සෑම දිනකට වරක් හෝ දෙවරක් එම සම සේවක ශාඛාව ඒකාබද්ධ කිරීම / නැවත ලබා ගැනීම තෝරා ගත හැකිය. ඒ ආකාරයෙන්, ඔබ ඒකාබද්ධ කිරීම / නැවත ගැටුම් සොයා ගන්නේ නම්, සෑම දෙයක්ම එක විශාල ගැටිත්තක් සමඟ ඒකාබද්ධ කිරීමට සති කිහිපයක් බලා සිටියහොත් ඔබට ඒවා ඉක්මණින් විසඳා ගත හැකිය.

ඉඟිය පහ

ඒකාබද්ධ කිරීමක් ගැන ඔබට විශ්වාස නැත්නම්, එය බල නොකරන්න.

ඒකාබද්ධ කිරීම අධික ලෙස දැනිය හැකිය, විශේෂයෙන් ගැටුම්කාරී ලිපිගොනු විශාල ප්‍රමාණයක් ඇති විට සහ ගැටුම් සලකුණු රේඛා සිය ගණනක් ආවරණය කරයි. බොහෝ විට මෘදුකාංග ව්‍යාපෘති තක්සේරු කිරීමේදී අප විසින් ඒකාබද්ධ කිරීමක් හැසිරවීම වැනි පොදු කාර්ය සඳහා ප්‍රමාණවත් කාලයක් ඇතුළත් නොකෙරේ, එබැවින් සෑම ගැටුමක්ම බෙදීමට පැය කිහිපයක් ගත කිරීම සැබෑ ඇදගෙන යාමක් ලෙස හැඟේ.

කල් යත්ම, කල්තියා සැලසුම් කිරීම සහ අනෙක් අය ක්‍රියා කරන්නේ කුමක් දැයි දැන ගැනීම ඒකාබද්ධ කිරීමේ ගැටුම් අපේක්ෂා කිරීම සඳහා හොඳම මෙවලම් වන අතර අඩු කාලයක් තුළ ඒවා නිවැරදිව විසඳීමට ඔබම සූදානම් වන්න.

1. ගැටුම් ඇති ගොනු මොනවාදැයි හඳුනා ගන්න (Git ඔබට මෙය පැවසිය යුතුය).

2. එක් එක් ගොනුව විවෘත කර වෙනස්කම් පරීක්ෂා කරන්න; Git ඒවා සලකුණු කරයි. සෑම බ්ලොක් එකකම කුමන අනුවාදය තබා ගත යුතුද යන්න පැහැදිලිය. කේතය සිදුකළ සෙසු සංවර්ධකයින් සමඟ ඔබට එය සාකච්ඡා කිරීමට අවශ්‍ය විය හැකිය.

3. ඔබ ගොනුවක ගැටුම නිරාකරණය කළ පසු git add the_file.

4. ඔබ සියලු ගැටුම් නිරාකරණය කළ පසු , කරන්න git rebase --continueහෝ ඔබ විසින් සම්පූර්ණ කරන විට කළ යුතු ඕනෑම විධානයක් කරන්න.

Stack පමාණය, ප්රශ්නයට පිළිතුරු පරීක්ෂා Git දී ඒකාබද්ධ දෝශයක් හටගෙන , විශේෂයෙන් චාල්ස් බේලි පිළිතුර උදාහරණයක් ලෙස, ප්රශ්න ගොනුවේ විවිධ තොරතුරු බැලීම ආකාරය වන දර්ශන,

# 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

ගොනුවකට එකවර වෙනස්කම් සිදු කළ විට ඒකාබද්ධ ගැටුම් සිදු වේ. මෙන්න එය විසඳන්නේ කෙසේද.

git සීඑල්අයි

ඔබ ගැටුම්කාරී තත්වයකට පත්වූ විට කළ යුතු සරල පියවර මෙන්න:

1. පහත දැක්වෙන ගැටුම් සහිත ලිපිගොනු ලැයිස්තුව සටහන් කරන්න: git status( Unmerged pathsකොටස යටතේ ).

2. පහත දැක්වෙන එක් ප්‍රවේශයකින් එක් එක් ගොනුව සඳහා ගැටුම් වෙන වෙනම විසඳන්න:

   • ගැටුම් නිරාකරණය කිරීම සඳහා GUI භාවිතා කරන්න: git mergetool(පහසුම ක්‍රමය).

   • දුරස්ථ / වෙනත් අනුවාදයක් පිළිගැනීමට, භාවිතා කරන්න : git checkout --theirs path/file. මෙම ගොනුව සඳහා ඔබ කළ දේශීය වෙනස්කම් මෙය ප්‍රතික්ෂේප කරනු ඇත.

   • දේශීය / අපගේ අනුවාදය පිළිගැනීමට, භාවිතා කරන්න: git checkout --ours path/file

     ^{කෙසේ වෙතත්, කිසියම් හේතුවක් නිසා ගැටුම් සිදු වූ දුරස්ථ වෙනස්කම් ලෙස ඔබ ප්‍රවේශම් විය යුතුය.}

     ආශ්‍රිත: “අපගේ” සහ “ඔවුන්ගේ” යන්නෙහි නියම අර්ථය කුමක්ද?

   • ගැටුම් සහිත ලිපිගොනු අතින් සංස්කරණය කර අතර ඇති කේත වාරණය සොයන්න <<<<</ >>>>>ඉන්පසු ඉහළ හෝ පහළින් අනුවාදය තෝරන්න =====. බලන්න: ගැටුම් ඉදිරිපත් කරන්නේ කෙසේද .

   • මාර්ගය සහ ගොනු නාම ගැටුම් git add/ මගින් විසඳා ගත හැකිය git rm.

3. අවසාන වශයෙන්, කැපවීම සඳහා සූදානම් ගොනු සමාලෝචනය කරන්න: git status .

   ඔබ සතුව කිසියම් ලිපිගොනුවක් තිබේ නම් Unmerged pathsසහ ගැටුම ඔබ විසින් අතින් විසඳා ඇත්නම්, ඔබ එය විසඳූ බව Git ට දන්වන්න : git add path/file.

4. සියලු ගැටුම් සාර්ථකව විසඳා ඇත්නම්, පහත පරිදි වෙනස්කම් සිදු කරන්න: git commit -aසුපුරුදු පරිදි දුරස්ථයට තල්ලු කරන්න.

මෙයද බලන්න: විධාන රේඛාවෙන් ඒකාබද්ධ කිරීමේ ගැටුමක් විසඳීම GitHub හි

ප්‍රායෝගික නිබන්ධනය සඳහා, පරීක්ෂා කරන්න: සිදුවීම 5 - කටකෝඩා විසින් ඒකාබද්ධ කිරීමේ ගැටුම් නිරාකරණය කිරීම .

වෙනස

මම සාර්ථකව DiffMerge භාවිතා කර ඇතවින්ඩෝස්, මැකෝස් සහ ලිනක්ස් / යුනික්ස් හි ගොනු දෘශ්‍ය සැසඳිය හැකි හා ඒකාබද්ධ කළ හැකි .

එය ගොනු 3 ක් අතර ඇති වෙනස්කම් ප්‍රස්ථාරිකව පෙන්විය හැකි අතර එය ස්වයංක්‍රීයව ඒකාබද්ධ කිරීමට (එසේ කිරීමට ආරක්ෂිත වූ විට) සහ එහි ප්‍රති ing ලයක් ලෙස ඇති ගොනුව සංස්කරණය කිරීමට පූර්ණ පාලනයක් ලබා දේ.

^{රූප මූලාශ්‍රය: DiffMerge (ලිනක්ස් තිර රුව)}

එය බාගත කර repo ලෙස ක්‍රියාත්මක කරන්න:

git mergetool -t diffmerge .

macOS

මැකෝස් මත ඔබට මෙය හරහා ස්ථාපනය කළ හැකිය:

brew install caskroom/cask/brew-cask
brew cask install diffmerge

බොහෝ විට (සපයා නොමැති නම්) ඔබේ PATH (උදා /usr/bin) හි තැන්පත් කර ඇති පහත සඳහන් අමතර සරල ආවරණයක් ඔබට අවශ්‍ය වේ :

#!/bin/sh
DIFFMERGE_PATH=/Applications/DiffMerge.app
DIFFMERGE_EXE=${DIFFMERGE_PATH}/Contents/MacOS/DiffMerge
exec ${DIFFMERGE_EXE} --nosplash "$@"

එවිට ඔබට පහත යතුරුපුවරු කෙටිමං භාවිතා කළ හැකිය:

• ⌘- Alt- Up/ Downපෙර / ඊළඟ වෙනස්කම් වලට පනින්න.
• ⌘- Alt- Left/ Rightවමේ හෝ දකුණේ වෙනස පිළිගැනීමට

විකල්පයක් ලෙස ඔබට ඔපෙන්ඩිෆ් ( එක්ස්කෝඩ් මෙවලම්වල කොටසක්) භාවිතා කළ හැකි අතර එමඟින් ලිපිගොනු හෝ නාමාවලි දෙකක් ඒකාබද්ධ කර තෙවන ගොනුවක් හෝ නාමාවලියක් නිර්මාණය කළ හැකිය.

ඔබ නිතර කුඩා කොමිස් කරන්නේ නම්, ඒ සමඟ ඇති අදහස් දැක්වීමෙන් ආරම්භ කරන්න git log --merge. ඉන්පසුgit diff ඔබට ගැටුම් පෙන්වනු ඇත.

පේළි කිහිපයකට වඩා සම්බන්ධ වන ගැටුම් සඳහා, බාහිර GUI මෙවලමක සිදුවන්නේ කුමක්ද යන්න බැලීම පහසුය. මම opendiff වලට කැමතියි - Git ද vimdiff, gvimdiff, kdiff3, tkdiff, meld, xxdiff, කොටුවෙන් එළියට එන අතර ඔබට වෙනත් ඒවා ස්ථාපනය කළ හැකිය: git config merge.tool "your.tool"ඔබ තෝරාගත් මෙවලම සකසා පසුවgit mergetool අතර අසාර්ථක ඒකාබද්ධ වීමෙන් පසුව සන්දර්භය තුළ ඇති වෙනස්කම් ඔබට පෙන්වනු ඇත.

ගැටුමක් නිරාකරණය කිරීම සඳහා ඔබ ගොනුවක් සංස්කරණය කරන සෑම අවස්ථාවකම git add filenameදර්ශකය යාවත්කාලීන කරනු ඇති අතර ඔබේ වෙනස තවදුරටත් එය පෙන්වන්නේ නැත. සියලු ගැටුම් හසුරුවන විට සහ ඒවායේ ලිපිගොනු git add-ed කර ඇති විට , git commitඔබේ ඒකාබද්ධ කිරීම සම්පූර්ණ වේ.

ගැටුම් ඉදිරිපත් කරන්නේ කෙසේදැයි බලන්න හෝ ගැට් git mergeසලකුණු ඒකාබද්ධ කිරීම යනු කුමක්දැයි වටහා ගැනීම සඳහා වන ලියකියවිලි බලන්න.

එසේම, ගැටුම් නිරාකරණය කරන්නේ කෙසේද යන කොටස ගැටුම් නිරාකරණය කරන්නේ කෙසේද යන්න පැහැදිලි කරයි:

ගැටුමක් දුටු පසු, ඔබට කරුණු දෙකක් කළ හැකිය:

• ඒකාබද්ධ නොකිරීමට තීරණය කරන්න. ඔබට අවශ්‍ය එකම පිරිසිදු කිරීම වන්නේ දර්ශක ගොනුව HEAD2 ආපසු හැරවීමට ඇති කැපවීම වෙත නැවත සකස් කිරීම සහ 2. සහ 3 විසින් සිදු කරන ලද වැඩ කරන ගස් වෙනස්කම් පිරිසිදු කිරීමයි. git merge --abortමේ සඳහා භාවිතා කළ හැකිය.

• ගැටුම් නිරාකරණය කරන්න. වැඩ කරන ගසෙහි ගැටුම් Git විසින් සලකුණු කරනු ඇත. ගොනු හැඩයට සහ git addඒවා දර්ශකයට සංස්කරණය කරන්න . git commitගනුදෙනුව මුද්‍රා තැබීමට භාවිතා කරන්න .

මෙවලම් ගණනාවක් සමඟ ගැටුම හරහා ඔබට වැඩ කළ හැකිය:

• Mergetool භාවිතා කරන්න. git mergetoolඒකාබද්ධ කිරීම තුළින් ඔබට වැඩ කරන චිත්‍රක ඒකාබද්ධ කිරීමක් දියත් කිරීමට.

• වෙනස්කම් දෙස බලන්න. සහ අනුවාද git diffදෙකෙහිම වෙනස්කම් ඉස්මතු කරමින් ත්‍රි-මාර්ග වෙනසක් පෙන්වනු ඇත.HEADMERGE_HEAD

• සෑම ශාඛාවකින්ම ඇති වෙනස්කම් දෙස බලන්න. git log --merge -p <path>පළමුව HEADඅනුවාදය සහ පසුව අනුවාදය සඳහා වෙනස පෙන්වනු ඇත MERGE_HEAD.

• මුල් පිටපත් දෙස බලන්න. git show :1:filenameපොදු මුතුන් මිත්තෙකු git show :2:filenameපෙන්වයි, HEADඅනුවාදය git show :3:filenameපෙන්වයි , සහ MERGE_HEADඅනුවාදය පෙන්වයි .

ඒකාබද්ධ ගැටුම් සලකුණු සහ ඒවා විසඳන්නේ කෙසේද යන්න ගැන ප්‍රෝ ගැට් පොත් කොටසේ මූලික ඒකාබද්ධ කිරීමේ ගැටුම් පිළිබඳවද ඔබට කියවිය හැකිය .

එක්කෝ මට මගේ හෝ ඒවායේ අනුවාදය සම්පුර්ණයෙන්ම අවශ්‍යය, නැතහොත් තනි වෙනස්කම් සමාලෝචනය කර ඒවායින් එකක් තීරණය කිරීමට මට අවශ්‍යය.

මගේ හෝ ඔවුන්ගේ අනුවාදය සම්පූර්ණයෙන්ම පිළිගන්න :

මගේ අනුවාදය පිළිගන්න (දේශීය, අපේ):

git checkout --ours -- <filename>
git add <filename>              # Marks conflict as resolved
git commit -m "merged bla bla"  # An "empty" commit

ඔවුන්ගේ අනුවාදය පිළිගන්න (දුරස්ථ, ඔවුන්ගේ):

git checkout --theirs -- <filename>
git add <filename>
git commit -m "merged bla bla"

සියලුම ගැටුම් ලිපිගොනු ක්‍රියාත්මක කිරීම සඳහා ඔබට අවශ්‍ය නම් :

git merge --strategy-option ours

හෝ

git merge --strategy-option theirs

සියලු වෙනස්කම් සමාලෝචනය කර ඒවා තනි තනිව පිළිගන්න

1. git mergetool
2. වෙනස්කම් සමාලෝචනය කර එක් එක් අනුවාදය පිළිගන්න.
3. git add <filename>
4. git commit -m "merged bla bla"

පෙරනිමි විධාන රේඛාවේmergetool ක්‍රියා කරයි . විධාන රේඛා mergetool භාවිතා කරන්නේ කෙසේද යන්න වෙනම ප්‍රශ්නයක් විය යුතුය.

ඔබ ද ස්ථාපනය කළ හැකි දෘශ්ය මෙවලමක් මේ සඳහා, උදා: meldහා ලකුණු

git mergetool -t meld

එය දේශීය අනුවාදය (අපගේ), "පදනම්" හෝ "ඒකාබද්ධ" අනුවාදය (ඒකාබද්ධයේ වත්මන් ප්‍රති result ලය) සහ දුරස්ථ අනුවාදය (ඒවා) විවෘත කරනු ඇත. ඒකාබද්ධ කළ අනුවාදය ඔබ අවසන් වූ පසු සුරකින්න, git mergetool -t meldඔබට "ලිපිගොනු ඒකාබද්ධ කිරීම අවශ්‍ය නොවේ" ලැබෙන තෙක් නැවත ධාවනය කරන්න, ඉන්පසු පියවර 3 සහ 4 වෙත යන්න.

සඳහා හැරදමයි ඒකාබද්ධ ගැටුම් අවසන් පූර්ව අතින් විසඳීමට අවශ්ය පරිශීලකයින් සඳහා:

git diff --name-status --diff-filter=U

ගැටුම් නිරාකරණය අවශ්‍ය සියලුම ගොනු පෙන්වයි.

එම එක් එක් ලිපිගොනු එකින් එක විවෘත කරන්න, නැතහොත් සියල්ල එකවරම විවෘත කරන්න:

emacs $(git diff --name-only --diff-filter=U)

Emacs හි සංස්කරණ අවශ්‍ය බෆරයකට පිවිසෙන විට ටයිප් කරන්න

ALT+x vc-resolve-conflicts

මෙය බෆර තුනක් (මගේ, ඒවායේ සහ ප්‍රතිදාන බෆරය) විවෘත කරනු ඇත. 'N' (ඊළඟ කලාපය), 'p' (පෙරදසුන කලාපය) එබීමෙන් සැරිසැරීම. ප්‍රතිදාන බෆරයට පිළිවෙලින් මගේ හෝ ඒවායේ කලාපය පිටපත් කිරීමට 'a' සහ 'b' ඔබන්න. සහ / හෝ ප්‍රතිදාන බෆරය කෙලින්ම සංස්කරණය කරන්න.

අවසන් වූ විට: 'q' ඔබන්න. ඔබට මෙම බෆරය සුරැකීමට අවශ්‍ය දැයි ඊමාක්ස් ඔබෙන් අසයි: ඔව්. බෆරයක් අවසන් කිරීමෙන් පසු එය ටර්මිනලයේ සිට ධාවනය කිරීමෙන් විසඳා ඇති බව සලකුණු කරන්න:

git add FILENAME

සියලුම බෆර වර්ග සමඟ අවසන් වූ විට

git commit

ඒකාබද්ධ කිරීම අවසන් කිරීමට.

පාරිතෝෂිකය:

ඉහත පිළිතුරු වල අදින්න / ලබා ගැනීම / ඒකාබද්ධ කිරීම ගැන කථා කිරීමේදී, සිත්ගන්නාසුළු හා tive ලදායී උපක්‍රමයක් බෙදා ගැනීමට මම කැමතියි,

git pull --rebase

මෙම ඉහත විධානය මගේ git ජීවිතයේ වඩාත්ම ප්‍රයෝජනවත් විධානය වන අතර එය බොහෝ කාලයක් ඉතිරි කර ඇත.

ඔබගේ අලුතින් සිදුකරන ලද වෙනස දුරස්ථ සේවාදායකයට තල්ලු කිරීමට පෙර, ඒ git pull --rebaseවෙනුවට උත්සාහ git pullකර අත්පොත උත්සාහ කරන්න merge, එය ස්වයංක්‍රීයව නවතම දුරස්ථ සේවාදායක වෙනස්කම් සමමුහුර්ත කරනු ඇත (ලබා ගැනීම + ඒකාබද්ධ කිරීම සමඟ) සහ ඔබේ දේශීය නවතම කැපවීම ඉහළින්ම git ලොගයට දමනු ඇත. අතින් අදින්න / ඒකාබද්ධ කිරීම ගැන කරදර විය යුතු නැත.

ගැටුමකදී පමණක් භාවිතා කරන්න

git mergetool
git add conflict_file
git rebase --continue

විස්තර සොයන්න: http://gitolite.com/git-pull--rebase

සරලවම, එක් ගබඩාවක සිදුවන වෙනස්කම් වැදගත් නොවන බව ඔබ හොඳින් දන්නේ නම් සහ අනෙකාට පක්ෂව සියලු වෙනස්කම් විසඳීමට අවශ්‍ය නම්, භාවිතා කරන්න:

git checkout . --ours

ඔබේ ගබඩාවට පක්ෂව සිදුවන වෙනස්කම් විසඳීමට , හෝ

git checkout . --theirs

අනෙක් හෝ ප්‍රධාන ගබඩාවට පක්ෂව වෙනස්කම් විසඳීමට .

නැතිනම් ඔබට GUI ඒකාබද්ධ කිරීමේ මෙවලමක් භාවිතා කිරීමට සිදුවනු ඇත, එකින් එක ලිපිගොනු හරහා ගමන් කිරීම, ඒකාබද්ධ කිරීමේ මෙවලම යැයි කියන්න p4merge, නැතහොත් ඔබ දැනටමත් ස්ථාපනය කර ඇති ඕනෑම කෙනෙකුගේ නමක් ලියන්න

git mergetool -t p4merge

ගොනුවක් අවසන් කිරීමෙන් පසු, ඔබට සුරැකීමට හා වැසීමට සිදුවේ, එවිට ඊළඟ එක විවෘත වේ.

Git හි ඒකාබද්ධ කිරීමේ ගැටුම් නිරාකරණය කිරීමට කරුණාකර පහත පියවර අනුගමනය කරන්න:

1. Git තත්ත්වය පරීක්ෂා කරන්න: git තත්ත්වය

2. පැච්සෙට් එක ගන්න: git fetch (ඔබගේ Git commit වෙතින් නිවැරදි පැච් එක පරීක්ෂා කරන්න)

3. දේශීය ශාඛාවක් පරීක්ෂා කරන්න (මෙහි මගේ උදාහරණයේ temp1): git checkout -b temp1

4. මාස්ටර් වෙතින් මෑත අන්තර්ගතයන් අදින්න: අදින්න git pull --rebase origin master

5. Mergetool ආරම්භ කර ගැටුම් පරීක්ෂා කර ඒවා නිවැරදි කරන්න ... සහ දුරස්ථ ශාඛාවේ වෙනස්කම් ඔබගේ වර්තමාන ශාඛාව සමඟ පරීක්ෂා කරන්න: git mergetool

6. තත්වය නැවත පරීක්ෂා කරන්න: git තත්ත්වය

7. Mergetool විසින් දේශීයව සාදන ලද අනවශ්‍ය ලිපිගොනු මකන්න, සාමාන්‍යයෙන් mergetool * .orig දිගුව සමඟ අමතර ගොනුවක් සාදයි. කරුණාකර එම ගොනුව අනුපිටපතක් ලෙස මකා දමා දේශීයව වෙනස්කම් නිවැරදි කර ඔබගේ ලිපිගොනු වල නිවැරදි අනුවාදය එක් කරන්න. git #your_changed_correct_files එක් කරන්න

8. තත්වය නැවත පරීක්ෂා කරන්න: git තත්ත්වය

9. එකම කැපවීමේ හැඳුනුම්පතට වෙනස්කම් කරන්න (මෙය නව වෙනම පැච් කට්ටලයක් මග හැරේ): git commit --amend

10. ප්‍රධාන ශාඛාවට තල්ලු කරන්න : git push (ඔබේ Git ගබඩාවට)

පියවර 3 ක් ඇත:

1. විධානය මඟින් ගැටුම් ඇති කරන්නේ කුමන ගොනුදැයි සොයා බලන්න

   git status
   

2. ගැටුම් ලෙස සලකුණු කර ඇති ලිපිගොනු පරීක්ෂා කරන්න

   <<<<<<<<head
   blablabla
   

3. එය ඔබට අවශ්‍ය ආකාරයට වෙනස් කරන්න, ඉන්පසු විධාන සමඟ බැඳී සිටින්න

   git add solved_conflicts_files
   git commit -m 'merge msg'
   

අනෙක් ඒවා සවිස්තරව දක්වා ඇති පරිදි ඒකාබද්ධ කිරීමේ ගැටුම් ඔබට ක්‍රම කිහිපයකින් නිවැරදි කළ හැකිය.

දේශීය හා දුරස්ථ ගබඩාවන් සමඟ වෙනස්කම් ගලා යන්නේ කෙසේදැයි දැන ගැනීම සැබෑ යතුර යැයි මම සිතමි. මෙහි ප්‍රධාන දෙය නම් ලුහුබැඳීමේ ශාඛා තේරුම් ගැනීමයි. මගේ දේශීය, සත්‍ය ලිපිගොනු නාමාවලිය සහ දුරස්ථ මූලාරම්භය අතර මා අතර ඇති 'මැද නැතිවූ කොටස' ලෙස මම ලුහුබැඳීමේ ශාඛාව සිතන බව සොයාගෙන ඇත.

මෙය වළක්වා ගැනීම සඳහා මම පෞද්ගලිකව කරුණු 2 ක පුරුද්දට වැටී සිටිමි.

වෙනුවට:

git add .
git commit -m"some msg"

එහි අඩුපාඩු දෙකක් තිබේ -

අ) සියලුම නව / වෙනස් කළ ලිපිගොනු එකතු වන අතර එයට අනවශ්‍ය වෙනස්කම්ද ඇතුළත් විය හැකිය.
b) ඔබට පළමුව ගොනු ලැයිස්තුව සමාලෝචනය කිරීමට ලැබෙන්නේ නැත.

ඒ වෙනුවට මම කරන්නේ:

git add file,file2,file3...
git commit # Then type the files in the editor and save-quit.

මේ ආකාරයෙන් ඔබ එකතු කරන්නේ කුමන ලිපිගොනු ගැනද යන්න පිළිබඳව ඔබ වඩාත් හිතාමතාම සිටින අතර ඔබට ලැයිස්තුව සමාලෝචනය කර පණිවිඩය සඳහා සංස්කාරකය භාවිතා කරන අතරතුර තව ටිකක් සිතන්න. මම -mවිකල්පයට වඩා සම්පූර්ණ තිර සංස්කාරකයක් භාවිතා කරන විට එය මගේ කැපවීමේ පණිවිඩ වැඩි දියුණු කරන බව මට පෙනේ.

[යාවත්කාලීන කිරීම - කාලය ගෙවී යත්ම මම තව දුරටත් මාරුවී ඇත්තේ:

git status # Make sure I know whats going on
git add .
git commit # Then use the editor

]

එසේම (සහ ඔබේ තත්වයට වඩා අදාළ), මම වැළකී සිටීමට උත්සාහ කරමි:

git pull

හෝ

git pull origin master.

අදින්න යනු ඒකාබද්ධ කිරීමක් අදහස් කරන අතර ඔබට ඒකාබද්ධ වීමට අවශ්‍ය නොවන දේශීය වෙනස්කම් තිබේ නම් ඔබට පහසුවෙන් ඒකාබද්ධ කළ කේත සමඟ අවසන් විය හැකි අතර / හෝ ඒකාබද්ධ නොකළ යුතු කේත සඳහා ගැටුම් ඒකාබද්ධ කළ හැකිය.

ඒ වෙනුවට මම කරන්න උත්සාහ කරනවා

git checkout master
git fetch   
git rebase --hard origin/master # or whatever branch I want.

ඔබට මෙය ප්‍රයෝජනවත් විය හැකිය:

git branch, දෙබලක, ලබා ගැනීම, ඒකාබද්ධ කිරීම, නැවත සකස් කිරීම සහ ක්ලෝන කිරීම, වෙනස්කම් මොනවාද?

CoolAJ86 හි පිළිතුර සෑම දෙයක්ම සාරාංශ කරයි. ඔබට එකම කේත කැබැල්ලක ශාඛා දෙකෙහිම වෙනස්කම් තිබේ නම් ඔබට අතින් ඒකාබද්ධ කිරීමක් කිරීමට සිදුවේ. ඕනෑම පෙළ සංස්කාරකයක ගැටුමක ඇති ගොනුව විවෘත කරන්න, ඔබ පහත ව්‍යුහය දැකිය යුතුය.

(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)

සමාන සං signs ා සහ කෝණ වරහන් ඉවත් කරන අතරම ඔබට නව කේතයක් වීමට අවශ්‍ය ආකාරයට විකල්ප එකක් හෝ දෙකේම එකතුවක් තෝරන්න.

git commit -a -m "commit message"
git push origin master

git log --merge -p [[--] path]

සෑම විටම මා වෙනුවෙන් වැඩ කරන බවක් නොපෙනෙන අතර සාමාන්‍යයෙන් ශාඛා දෙක අතර වෙනස් වූ සෑම කැපවීමක්ම ප්‍රදර්ශනය කරයි, මෙය සිදු වන්නේ විධානයෙන් --මාර්ගය වෙන් කිරීමට භාවිතා කරන විටදීය .

මෙම ගැටළුව විසඳීම සඳහා මා කරන්නේ විධාන රේඛා දෙකක් සහ එක් ධාවනයක් විවෘත කිරීමයි

git log ..$MERGED_IN_BRANCH --pretty=full -p [path]

සහ අනෙක්

git log $MERGED_IN_BRANCH.. --pretty=full -p [path]

$MERGED_IN_BRANCHමා ඒකාබද්ධ කළ ශාඛාව හා [path]ප්‍රතිවිරුද්ධ ගොනුව සමඟ ප්‍රතිස්ථාපනය කිරීම . මෙම විධානය මඟින් සියලු කොමිස්, පැච් ස්වරූපයෙන්, ( ..) කොමිට් දෙකක් අතර ලොග් කරනු ඇත . ඉහත විධානයන් මෙන් ඔබ එක් පැත්තක් හිස්ව තැබුවහොත් git ස්වයංක්‍රීයව භාවිතා වේ HEAD(මෙම අවස්ථාවේදී ඔබ ඒකාබද්ධ වන ශාඛාව).

ශාඛා දෙකෙන් අපසරනය වූ පසු ගොනුව තුළට ගිය දේ බැලීමට මෙය ඔබට ඉඩ සලසයි. එය සාමාන්‍යයෙන් ගැටුම් නිරාකරණය කිරීම වඩාත් පහසු කරයි.

භාවිතා කිරීම patience

patienceඒකාබද්ධ පුනරාවර්තන උපාය මාර්ගයෙන් ගැටුම් නිරාකරණය කිරීම ගැන වෙනත් කිසිවෙකු කතා නොකිරීම මට පුදුමයකි . විශාල ඒකාබද්ධ කිරීමේ ගැටුමක් සඳහා, භාවිතා patienceකිරීම මට හොඳ ප්‍රති results ල ලබා දී ඇත. අදහස නම් එය තනි රේඛාවලට වඩා කුට්ටි ගැලපීමට උත්සාහ කරනු ඇති බවයි.

නිදසුනක් ලෙස ඔබ ඔබේ වැඩසටහනේ ඉන්ඩෙන්ටේෂන් වෙනස් කරන්නේ නම්, පෙරනිමි Git ඒකාබද්ධ කිරීමේ උපායමාර්ගය සමහර විට {විවිධ කාර්යයන් වලට අයත් තනි වරහන් සමඟ ගැලපේ . මෙය වළක්වා ගන්නේ patience:

git merge -s recursive -X patience other-branch

ප්‍රලේඛනයෙන්:

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.

පොදු මුතුන් මිත්තෙකු සමඟ සංසන්දනය කිරීම

ඔබට ඒකාබද්ධ කිරීමේ ගැටුමක් තිබේ නම් සහ ඔවුන්ගේ ශාඛාව වෙනස් කිරීමේදී අනෙක් අයගේ මනසෙහි ඇති දේ දැකීමට අවශ්‍ය නම්, සමහර විට ඔවුන්ගේ ශාඛාව පොදු මුතුන් මිත්තෙකු සමඟ (අපගේ ශාඛාව වෙනුවට) කෙලින්ම සංසන්දනය කිරීම පහසුය. ඒ සඳහා ඔබට භාවිතා කළ හැකිය merge-base:

git diff $(git merge-base <our-branch> <their-branch>) <their-branch>

සාමාන්‍යයෙන්, ඔබට අවශ්‍ය වන්නේ විශේෂිත ගොනුවක් සඳහා වන වෙනස්කම් පමණි:

git diff $(git merge-base <our-branch> <their-branch>) <their-branch> <file>

2016 දෙසැම්බර් 12 දින වන විට, ඔබට ශාඛා ඒකාබද්ධ කර github.com හි ගැටුම් නිරාකරණය කළ හැකිය

මේ අනුව, පැරණි පිළිතුරු වලින් විධාන රේඛාව හෝ තෙවන පාර්ශවීය මෙවලම් භාවිතා කිරීමට ඔබට අවශ්‍ය නැතිනම් , GitHub හි ස්වදේශීය මෙවලම සමඟ යන්න.

මෙම බ්ලොග් සටහන විස්තරාත්මකව පැහැදිලි කරයි, නමුත් මූලික කරුණු වන්නේ යූඅයි හරහා ශාඛා දෙකක් ඒකාබද්ධ කිරීමෙන් පසු, ඔබට දැන් 'ගැටුම් නිරාකරණය' විකල්පයක් පෙනෙනු ඇති අතර එමඟින් ඔබට ඒකාබද්ධ කිරීමේ ගැටුම් සමඟ කටයුතු කිරීමට ඉඩ සලසන සංස්කාරකවරයකු වෙත ගෙන යනු ඇත.

ඔබට ශාඛා (පරීක්ෂණය) සිට ස්වාමියා දක්වා ඒකාබද්ධ වීමට අවශ්‍ය නම්, ඔබට මෙම පියවර අනුගමනය කළ හැකිය:

පියවර 1 : ශාඛාවට යන්න

git checkout test

පියවර 2 :

git pull --rebase origin master

පියවර 3 : යම් ගැටුම් තිබේ නම්, එය වෙනස් කිරීමට මෙම ලිපිගොනු වෙත යන්න.

පියවර 4 : මෙම වෙනස්කම් එක් කරන්න

git add #your_changes_files

පියවර 5 :

git rebase --continue

පියවර 6 : තවමත් ගැටුම් පවතී නම්, නැවත 3 වන පියවර වෙත යන්න. ගැටුමක් නොමැති නම්, පහත සඳහන් දේ කරන්න:

git push origin +test

පියවර 7 : එවිට පරීක්ෂණය සහ ස්වාමියා අතර ගැටුමක් නොමැත. ඔබට ඒකාබද්ධ කිරීම කෙලින්ම භාවිතා කළ හැකිය.

ගැටුම් වළක්වා ගැනීම සඳහා මම සෑම විටම පහත පියවර අනුගමනය කරමි.

• git checkout master (ප්‍රධාන ශාඛාවට එන්න)
• git pull (නවතම කේතය ලබා ගැනීම සඳහා ඔබේ ස්වාමියා යාවත්කාලීන කරන්න)
• git checkout -b mybranch (නව ශාඛාවක් පරීක්ෂා කර එම ශාඛාවේ වැඩ ආරම්භ කරන්න එවිට ඔබේ ස්වාමියා නිතරම කඳට ඉහළින් සිටියි.)
• git add. සහ git commit සහ git push (ඔබගේ වෙනස්වීම් වලින් පසු ඔබේ ප්‍රාදේශීය ශාඛාවේ)
• git checkout master (ඔබේ ස්වාමියා වෙත නැවත එන්න.)

දැන් ඔබට එයම කළ හැකි අතර ඔබට අවශ්‍ය දේශීය ශාඛා බොහොමයක් පවත්වා ගෙන යා හැකි අතර අවශ්‍ය විටෙක ඔබේ ශාඛාවට Git checkout කිරීම එකවර කළ හැකිය.

ඒකාබද්ධ කිරීමේ ගැටුම් විවිධ අවස්ථාවන්හිදී සිදුවිය හැකිය:

• "Git fetch" ධාවනය කරන විට "git merge"
• "Git fetch" ධාවනය කර "git rebase" ධාවනය කරන විට
• "Git pull" ධාවනය කරන විට (එය ඇත්ත වශයෙන්ම ඉහත සඳහන් කොන්දේසි වලින් එකකට සමාන වේ)
• "Git stash pop" ධාවනය කරන විට
• ඔබ git patches යෙදෙන විට (මාරු කළ යුතු ලිපිගොනු වෙත අපනයනය කරන කොමිස්, උදාහරණයක් ලෙස විද්‍යුත් තැපෑලෙන්)

ගැටුම් නිරාකරණය කිරීම සඳහා ඔබ Git සමඟ අනුකූල වන ඒකාබද්ධ කිරීමේ මෙවලමක් ස්ථාපනය කළ යුතුය. මම පෞද්ගලිකව KDiff3 භාවිතා කරන අතර, මම එය ලස්සන හා පහසු බව සොයාගෙන ඇත. ඔබට එහි වින්ඩෝස් අනුවාදය මෙතැනින් බාගත හැකිය:

https://sourceforge.net/projects/kdiff3/files/

BTW ඔබ Git Extensions ස්ථාපනය කරන්නේ නම් එහි සැකසුම් විශාරදයේ Kdiff3 ස්ථාපනය කිරීමට විකල්පයක් ඇත.

Kdiff එහි mergetool ලෙස භාවිතා කිරීමට git configs සකසන්න:

$ git config --global --add merge.tool kdiff3
$ git config --global --add mergetool.kdiff3.path "C:/Program Files/KDiff3/kdiff3.exe"
$ git config --global --add mergetool.kdiff3.trustExitCode false

$ git config --global --add diff.guitool kdiff3
$ git config --global --add difftool.kdiff3.path "C:/Program Files/KDiff3/kdiff3.exe"
$ git config --global --add difftool.kdiff3.trustExitCode false

(Kdiff exe ගොනුවේ සත්‍ය මාර්ගය වෙනුවට මාර්ගය ප්‍රතිස්ථාපනය කිරීමට මතක තබා ගන්න.)

ඒකාබද්ධ කිරීමේ ගැටුමකට මුහුණ දෙන සෑම අවස්ථාවකම ඔබට මෙම විධානය ක්‍රියාත්මක කළ යුතුය:

$git mergetool

ඉන්පසු එය Kdiff3 විවෘත කරයි, පළමුව ඒකාබද්ධ කිරීමේ ගැටුම් ස්වයංක්‍රීයව විසඳීමට උත්සාහ කරයි. බොහෝ ගැටුම් ස්වයංසිද්ධව විසඳනු ඇති අතර ඉතිරි සියල්ල ඔබ අතින් සකස් කළ යුතුය.

Kdiff3 පෙනුම මෙයයි:

ඔබ අවසන් වූ පසු, ගොනුව සුරකින්න, එය ගැටුම සමඟ ඊළඟ ගොනුව වෙත යන අතර සියලු ගැටුම් නිරාකරණය වන තෙක් ඔබ නැවත එම දේම කරයි.

සියල්ල සාර්ථකව ඒකාබද්ධ වී ඇත්දැයි පරීක්ෂා කිරීමට, නැවත mergetool විධානය ක්‍රියාත්මක කරන්න, ඔබට මෙම ප්‍රති result ලය ලබා ගත යුතුය:

$git mergetool
No files need merging

මෙම පිළිතුරු වන්නේ මා වැනි VIM භාවිතා කරන්නන් සඳහා සංස්කාරකය තුළ සෑම දෙයක්ම කිරීමට කැමති විකල්පයක් එක් කිරීමයි.

ටීඑල්; ඩී.ආර්

Tpope විම් නම් මේ මහත් ප්ලගිනය සමග පැමිණි පලා . ස්ථාපනය කිරීමෙන් පසු :Gstatusගැටුම් ඇති ලිපිගොනු පරීක්ෂා කිරීමට සහ :Gdiffඒකාබද්ධ කිරීම සඳහා Git විවෘත කිරීමට ඔබට හැකිය .

3-මාර්ග ඒකාබද්ධ වූ පසු, පලායාම මඟින් ඔබ ඒකාබද්ධ කරන ඕනෑම ශාඛාවක වෙනස්කම් පහත දැක්වෙන ආකාරයෙන් ලබා ගැනීමට ඔබට ඉඩ සලසයි:

• :diffget //2, මුල් ( HEAD ) ශාඛාවෙන් වෙනස්කම් ලබා ගන්න :
• :diffget //3, ශාඛාව ඒකාබද්ධ කිරීමෙන් වෙනස්කම් ලබා ගන්න:

ගොනුව ඒකාබද්ධ කිරීම අවසන් වූ පසු :Gwrite, ඒකාබද්ධ කළ බෆරය ටයිප් කරන්න . මෙම පියවර විස්තරාත්මකව විස්තර කරමින් විම්කාස්ට්ස් විශිෂ්ට වීඩියෝවක් නිකුත් කළේය .

VS කේතය සඳහා Gitlense

VS කේතය සඳහා ඔබට Gitlense උත්සාහ කළ හැකිය , ඒවායේ ප්‍රධාන ලක්ෂණ වන්නේ:

3. ගැටුම් පහසුවෙන් විසඳන්න.

මම දැනටමත් මෙම අංගයට කැමතියි:

2. වත්මන් රේඛීය දොස්.

3. ගුප්ත දෝෂාරෝපණය

4. තත්ව තීරුව

ඔබට ඒවා මෙහි පරීක්ෂා කළ හැකි බොහෝ විශේෂාංග තිබේ .

බෝගයන්ගේ සැලකිය Git
GIT Checkout ඔබේ ශාඛා
GIT rebase ස්වාමියා

මෙම පියවරේදී ඔබ කැමති IDE භාවිතා කර ගැටුම නිරාකරණය කිරීමට උත්සාහ කරනු ඇත

Https://help.github.com/articles/resolve-a-merge-conflict-using-the-command-line/ ගොනුවේ ඇති ගැටුම නිරාකරණය කිරීම සඳහා හෝ පරීක්ෂා කිරීමට ඔබට මෙම සබැඳිය අනුගමනය කළ හැකිය.

git add
git rebase --continue
git commit --amend
git push origin HEAD: refs / draft / master (කෙටුම්පත් මෙන් තල්ලු කරන්න)

දැන් සෑම දෙයක්ම හොඳයි, ඔබේ කැපවීම ගෙරිට් වලින් ඔබට පෙනෙනු ඇත

මෙම ගැටළුව සම්බන්ධයෙන් සෑම කෙනෙකුටම මෙය උපකාරී වනු ඇතැයි මම බලාපොරොත්තු වෙමි.

ඔබ දැනටමත් නොමැති නම් සංස්කරණය සඳහා දෘශ්‍ය ස්ටුඩියෝ කේතය උත්සාහ කරන්න. එය සිදු වන්නේ ඔබ ඒකාබද්ධ කිරීමට උත්සාහ කිරීමෙන් පසුවය (සහ ඒකාබද්ධ කිරීමේ ගැටුම් වලට ගොඩ වන්න) .වීඑස් කේතය ස්වයංක්‍රීයව ඒකාබද්ධ කිරීමේ ගැටුම් හඳුනා ගනී.

එය මුල් එක් වෙත සිදු කරන ලද වෙනස් කම් මොනවාද පෙන්වමින් ඔබ ඉතා හොඳින් උපකාර කළ හැකි සහ ඔබ පිළිගත යුතුය incomingහෝ

current change(ඒකාබද්ධ කිරීමට පෙර මුල් පිටපතෙහි තේරුම) '?.

එය මට උදව් වූ අතර එය ඔබටත් වැඩ කළ හැකිය!

PS: එය ක්‍රියාත්මක වන්නේ ඔබ ඔබේ කේතය සහ දෘශ්‍ය ස්ටුඩියෝ කේතය සමඟ git වින්‍යාස කර ඇත්නම් පමණි.

ගැටුම් නිරාකරණය සඳහා ආරක්ෂිත ක්‍රමයක් වන්නේ git- mediate භාවිතා කිරීමයි (මෙහි යෝජනා කර ඇති පොදු විසඳුම් තරමක් දෝෂ සහිත ඉමෝ වේ).

එය භාවිතා කරන්නේ කෙසේද යන්න පිළිබඳ ඉක්මන් හැඳින්වීමක් සඳහා මෙම ලිපිය බලන්න .

විෂුවල් ස්ටුඩියෝ භාවිතා කරන අය සඳහා (2015 මගේ නඩුවේ)

1. VS හි ඔබේ ව්‍යාපෘතිය වසා දමන්න. විශේෂයෙන් විශාල ව්‍යාපෘති වලදී VS යූඅයි භාවිතා කරන විට ඒකාබද්ධ වේ.

2. ඒකාබද්ධ විධාන විමසුමේ කරන්න.

   git checkout target_branch

   git merge source_branch

3. ඉන්පසු ව්‍යාපෘතිය VS හි විවෘත කර Team Explorer -> Branch වෙත යන්න. දැන් පණිවිඩයක් තිබේ, ඒකාබද්ධ කිරීම ඉතිරිව ඇති අතර ගැටුම්කාරී ලිපිගොනු පණිවිඩයට පහළින් ලැයිස්තුගත කර ඇත.

4. ගැටුම්කාරී ගොනුව ක්ලික් කරන්න, ඔබට ඒකාබද්ධ කිරීම, සංසන්දනය කිරීම, මූලාශ්‍රය ගැනීම, ඉලක්කය ගැනීම යන විකල්පය ඇත. VS හි ඒකාබද්ධ කිරීමේ මෙවලම භාවිතා කිරීම ඉතා පහසුය.

ඔබ අයිඩීඊ ලෙස ඉන්ටෙලිජේ භාවිතා කරන්නේ නම් දෙමව්පියන් ඔබේ ශාඛාවට ඒකාබද්ධ කිරීමට උත්සාහ කරන්න

git checkout <localbranch>
git merge origin/<remotebranch>

එය මේ ආකාරයේ සියලු ගැටුම් පෙන්වනු ඇත

A_MBPro: test anu $ git ඒකාබද්ධ කිරීමේ සම්භවය / ස්වයංක්‍රීයව ඒකාබද්ධ කිරීම src / test / java / com /.../ TestClass.java CONFLICT (content): src / test / java / com /.../ TestClass.java හි ගැටුම් ඒකාබද්ධ කරන්න.

TestClass.java ගොනුව intelliJ හි රතු පැහැයෙන් දක්වා ඇති බව දැන් සටහන් කර ගන්න. එසේම git තත්ත්වය පෙන්වනු ඇත

Unmerged paths:
(use "git add <file>..." to mark resolution)
both modified:   src/test/java/com/.../TestClass.java

IntelliJ හි ගොනුව විවෘත කරන්න, එයට කොටස් ඇත

  <<<<<<< HEAD
    public void testMethod() {
    }
    =======
    public void testMethod() { ...
    }
    >>>>>>> origin/<remotebranch>

HEAD යනු ඔබේ ප්‍රාදේශීය ශාඛාවේ වෙනස්වීම් වන අතර දුරස්ථ ශාඛාවේ ආරම්භය / වේ. මෙන්න ඔබට අවශ්‍ය දේවල් තබාගෙන ඔබට අවශ්‍ය නොවන දෑ ඉවත් කරන්න. ඉන්පසු සාමාන්‍ය පියවරයන් කළ යුතුය. එනම්

   git add TestClass.java
   git commit -m "commit message"
   git push

ගැටුම් නිරාකරණය සඳහා මම මයික්‍රොසොෆ්ට් හි දෘශ්‍ය කේතය භාවිතා කරමි. එය භාවිතා කිරීම ඉතා සරල ය. මම මගේ ව්‍යාපෘතිය වැඩබිම තුළ විවෘතව තබමි. එය ගැටුම් හඳුනාගෙන ඉස්මතු කරයි, එපමණක් නොව, මට හෙඩ් හෝ එන එන දේවලින් තබා ගැනීමට අවශ්‍ය ඕනෑම වෙනසක් තෝරා ගැනීමට GUI විකල්ප ලබා දෙන්න.