git-merge-base - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

git-merge-base - ഒരു ലയനത്തിനായി കഴിയുന്നത്ര നല്ല പൊതു പൂർവ്വികരെ കണ്ടെത്തുക

സിനോപ്സിസ്

ജിറ്റിനെ ലയനം-അടിസ്ഥാനം [-a|--എല്ലാം] ...
ജിറ്റിനെ ലയനം-അടിസ്ഥാനം [-a|--എല്ലാം] --ഒക്ടോപസ് ...
ജിറ്റിനെ ലയനം-അടിസ്ഥാനം --പൂർവ്വികനാണ്
ജിറ്റിനെ ലയനം-അടിസ്ഥാനം --സ്വതന്ത്ര ...
ജിറ്റിനെ ലയനം-അടിസ്ഥാനം --ഫോർക്ക്-പോയിന്റ് [ ]

വിവരണം

ജിറ്റിനെ ലയനം-അടിസ്ഥാനം ത്രീ-വേയിൽ ഉപയോഗിക്കാനുള്ള രണ്ട് കമ്മിറ്റുകൾക്കിടയിലുള്ള ഏറ്റവും മികച്ച പൊതു പൂർവ്വികരെ(കളെ) കണ്ടെത്തുന്നു
ലയിപ്പിക്കുക. ഒരു പൊതു പൂർവ്വികനാണ് നല്ലത് മറ്റൊരു പൊതു പൂർവ്വികനെക്കാൾ രണ്ടാമത്തേത് ഒരു ആണെങ്കിൽ
മുൻ പൂർവ്വികൻ. മെച്ചപ്പെട്ട പൊതു പൂർവ്വികർ ഇല്ലാത്ത ഒരു പൊതു പൂർവ്വികനാണ്
a മികച്ച സാധാരണ പൂർവികൻ, അതായത് a ലയിപ്പിക്കുക അടിസ്ഥാനം. ഒന്നിൽ കൂടുതൽ ലയന ബേസ് ഉണ്ടാകാം എന്നത് ശ്രദ്ധിക്കുക
ഒരു ജോടി കമ്മിറ്റുകൾക്ക്.

പ്രവർത്തനം മോഡുകൾ

ഏറ്റവും സാധാരണമായ പ്രത്യേക കേസ് എന്ന നിലയിൽ, കമാൻഡ് ലൈനിൽ രണ്ട് കമ്മിറ്റുകൾ മാത്രം വ്യക്തമാക്കുന്നത് അർത്ഥമാക്കുന്നു
നൽകിയിരിക്കുന്ന രണ്ട് കമ്മിറ്റുകൾക്കിടയിലുള്ള ലയന അടിത്തറ കണക്കാക്കുന്നു.

കൂടുതൽ പൊതുവായി, ലയന അടിസ്ഥാനം കണക്കാക്കുന്നതിനുള്ള രണ്ട് കമ്മിറ്റുകളിൽ ഒന്ന് വ്യക്തമാക്കുന്നു
കമാൻഡ് ലൈനിലെ ആദ്യത്തെ കമ്മിറ്റ് ആർഗ്യുമെന്റ്; മറ്റേത് ഒരു (ഒരുപക്ഷേ
സാങ്കൽപ്പിക) കമാൻഡ് ലൈനിലെ ശേഷിക്കുന്ന എല്ലാ കമ്മിറ്റുകളിലുമുള്ള ലയനമാണ് കമ്മിറ്റ്.

അനന്തരഫലമായി, ദി ലയിപ്പിക്കുക അടിസ്ഥാനം ഓരോ പ്രതിബദ്ധതയിലും അടങ്ങിയിരിക്കണമെന്നില്ല
രണ്ടിൽ കൂടുതൽ കമ്മിറ്റുകൾ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ ആർഗ്യുമെന്റുകൾ. ഇതിൽ നിന്ന് വ്യത്യസ്തമാണ് ജിറ്റ്-ഷോ-
ശാഖ(1) --merge-base ഓപ്ഷൻ ഉപയോഗിക്കുമ്പോൾ.

--നീരാളി
ഒരു എൻ-വേയ്‌ക്കുള്ള തയ്യാറെടുപ്പിനായി, വിതരണം ചെയ്ത എല്ലാ കമ്മിറ്റുകളുടെയും ഏറ്റവും മികച്ച പൊതു പൂർവ്വികരെ കണക്കാക്കുക
ലയിപ്പിക്കുക. ഇത് പെരുമാറ്റത്തെ അനുകരിക്കുന്നു ജിറ്റിനെ ഷോ-ശാഖ --ലയിപ്പിക്കൽ-അടിസ്ഥാനം.

--സ്വതന്ത്ര
മെർജ് ബേസുകൾ പ്രിന്റ് ചെയ്യുന്നതിനുപകരം, വിതരണം ചെയ്ത കമ്മിറ്റുകളുടെ ഏറ്റവും കുറഞ്ഞ ഉപവിഭാഗം പ്രിന്റ് ചെയ്യുക
അതേ പൂർവ്വികർ. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, നൽകിയിരിക്കുന്ന കമ്മിറ്റുകളിൽ, കഴിയാത്തവ പട്ടികപ്പെടുത്തുക
മറ്റേതിൽ നിന്നും എത്തിച്ചേരാം. ഇത് പെരുമാറ്റത്തെ അനുകരിക്കുന്നു ജിറ്റിനെ ഷോ-ശാഖ --സ്വതന്ത്ര.

--പൂർവ്വികനാണ്
ആദ്യത്തേതാണോ എന്ന് പരിശോധിക്കുക രണ്ടാമന്റെ പൂർവ്വികനാണ് , ഒപ്പം പുറത്തുകടക്കുക
ശരിയാണെങ്കിൽ സ്റ്റാറ്റസ് 0, അല്ലെങ്കിൽ അല്ലെങ്കിൽ സ്റ്റാറ്റസ് 1. പിശകുകൾ പൂജ്യമല്ലാത്ത സ്റ്റാറ്റസാണ് സൂചിപ്പിക്കുന്നത്
അത് 1 അല്ല.

--ഫോർക്ക്-പോയിന്റ്
ഒരു ശാഖ (അല്ലെങ്കിൽ അതിലേക്ക് നയിക്കുന്ന ഏതെങ്കിലും ചരിത്രം) കണ്ടെത്തുക ) നിന്ന് ഫോർക്ക്ഡ്
മറ്റൊരു ശാഖ (അല്ലെങ്കിൽ ഏതെങ്കിലും റഫറൻസ്) . ഇത് കേവലം സാധാരണക്കാരനെ മാത്രം നോക്കുന്നില്ല
രണ്ടിന്റെയും പൂർവ്വികർ പ്രതിജ്ഞാബദ്ധരാണ്, മാത്രമല്ല അതിന്റെ റിഫ്ലോഗും കണക്കിലെടുക്കുന്നു എങ്കിൽ കാണാൻ
നയിക്കുന്ന ചരിത്രം ശാഖയുടെ മുൻ അവതാരത്തിൽ നിന്ന് ഫോർക്ക് ചെയ്തു
(ചുവടെയുള്ള ഈ മോഡിനെക്കുറിച്ചുള്ള ചർച്ച കാണുക).

ഓപ്ഷനുകൾ

-എ, --എല്ലാം
കമ്മിറ്റുകൾക്കുള്ള എല്ലാ ലയന ബേസുകളും ഔട്ട്‌പുട്ട് ചെയ്യുക, ഒന്നിന് പകരം.

DISCUSSION

രണ്ട് കമ്മിറ്റ് നൽകി A ഒപ്പം B, git merge-base AB-ൽ നിന്ന് എത്തിച്ചേരാവുന്ന ഒരു കമ്മിറ്റ് ഔട്ട്പുട്ട് ചെയ്യും
രണ്ടും A ഒപ്പം B രക്ഷാകർതൃ ബന്ധത്തിലൂടെ.

ഉദാഹരണത്തിന്, ഈ ടോപ്പോളജി ഉപയോഗിച്ച്:

o---o---o---ബി
/
---o---1---o---o---o---എ

തമ്മിലുള്ള ലയന അടിത്തറ A ഒപ്പം B is 1.

മൂന്ന് കമ്മിറ്റ് നൽകി A, B ഒപ്പം C, ജിറ്റ് മെർജ്-ബേസ് എബിസി തമ്മിലുള്ള ലയന അടിത്തറ കണക്കാക്കും A
ഒരു സാങ്കൽപ്പിക പ്രതിബദ്ധതയും M, ഇത് തമ്മിലുള്ള ലയനമാണ് B ഒപ്പം C. ഉദാഹരണത്തിന്, ഇതിനൊപ്പം
ടോപ്പോളജി:

o---o---o---o---സി
/
/ o---o---o---B
/ /
---2---1---o---o---o---എ

ജിറ്റ് മെർജ്-ബേസ് എബിസിയുടെ ഫലം 1. കാരണം a യ്‌ക്ക് തുല്യമായ ടോപ്പോളജി
ലയിപ്പിക്കുക M തമ്മിലുള്ള B ഒപ്പം C ഇതാണ്:

o---o---o---o---o
/\
/ o---o---o---o---എം
/ /
---2---1---o---o---o---എ

കൂടാതെ git മെർജ്-ബേസ് AM ന്റെ ഫലം 1. പ്രതിബദ്ധത 2 തമ്മിലുള്ള ഒരു പൊതു പൂർവ്വികൻ കൂടിയാണ് A
ഒപ്പം M, പക്ഷേ 1 മെച്ചപ്പെട്ട ഒരു പൊതു പൂർവ്വികനാണ്, കാരണം 2 ഒരു പൂർവ്വികനാണ് 1. അതുകൊണ്ട്, 2 ഒരു പക്ഷെ അത്
അടിസ്ഥാനം ലയിപ്പിക്കുക.

git merge-base --octopus ABC യുടെ ഫലം 2, കാരണം 2 മികച്ച പൊതു പൂർവ്വികനാണ്
എല്ലാ പ്രതിബദ്ധതകളുടെയും.

ചരിത്രത്തിൽ ക്രിസ്-ക്രോസ് ലയനങ്ങൾ ഉൾപ്പെടുമ്പോൾ, ഒന്നിൽ കൂടുതൽ ഉണ്ടാകാം മികച്ച സാധാരണ
രണ്ട് കമ്മിറ്റ് വേണ്ടി പൂർവ്വികൻ. ഉദാഹരണത്തിന്, ഈ ടോപ്പോളജി ഉപയോഗിച്ച്:

---1---o---എ
\/
X
/\
---2---o---o---ബി

രണ്ടും 1 ഒപ്പം 2 എ, ബി എന്നിവയുടെ ലയന ബേസുകളാണ്. ഒന്നും മറ്റൊന്നിനേക്കാൾ മികച്ചതല്ല (രണ്ടും
മികച്ച അടിസ്ഥാനങ്ങൾ ലയിപ്പിക്കുക). --all ഓപ്‌ഷൻ നൽകാത്തപ്പോൾ, ഏതാണ് മികച്ചതെന്ന് വ്യക്തമാക്കിയിട്ടില്ല
.ട്ട്‌പുട്ട്.

A, B എന്നീ രണ്ട് കമ്മിറ്റുകൾക്കിടയിലുള്ള "ഫാസ്റ്റ്-ഫോർവേഡ്-നെസ്" പരിശോധിക്കുന്നതിനുള്ള ഒരു പൊതു പദപ്രയോഗം ഇതാണ് (അല്ലെങ്കിൽ കുറഞ്ഞത്
ഉപയോഗിച്ചിരുന്നത്) എ, ബി എന്നിവയ്‌ക്കിടയിലുള്ള ലയന അടിത്തറ കണക്കാക്കാനും അത് എയ്‌ക്ക് തുല്യമാണോ എന്ന് പരിശോധിക്കാനും,
ഈ സാഹചര്യത്തിൽ, A എന്നത് B യുടെ പൂർവ്വികനാണ്. പഴയ ലിപികളിൽ പലപ്പോഴും ഈ ഭാഷാപ്രയോഗം ഉപയോഗിക്കുന്നത് നിങ്ങൾ കാണും.

A=$(git rev-parse --verify A)
ടെസ്റ്റ് ആണെങ്കിൽ "$A" = "$(git merge-base AB)"
അപ്പോള്
... എ ബിയുടെ പൂർവ്വികനാണ് ...
fi

ആധുനിക ജിറ്റിൽ, നിങ്ങൾക്ക് ഇത് കൂടുതൽ നേരിട്ടുള്ള രീതിയിൽ പറയാം:

git മെർജ്-ബേസ് ആണെങ്കിൽ --പൂർവിക എബി
അപ്പോള്
... എ ബിയുടെ പൂർവ്വികനാണ് ...
fi

പകരം.

DISCUSSION ON ഫോർക്ക്-പോയിന്റ് MODE

ജിറ്റ് ചെക്ക്ഔട്ട്-ബി ടോപ്പിക്ക് ഉത്ഭവം/മാസ്റ്റർ ഉപയോഗിച്ച് സൃഷ്‌ടിച്ച വിഷയ ശാഖയിൽ പ്രവർത്തിച്ചതിന് ശേഷം, ദി
റിമോട്ട്-ട്രാക്കിംഗ് ബ്രാഞ്ച് ഉത്ഭവം/മാസ്റ്റർ ചരിത്രം പുനർനിർമിക്കുകയും പുനർനിർമ്മിക്കുകയും ചെയ്‌തിരിക്കാം
ഈ രൂപത്തിന്റെ ചരിത്രത്തിലേക്ക്:

o---B1
/
---o---o---B2--o---o---o---B (ഉത്ഭവം/മാസ്റ്റർ)
\
B3
\
ഉരുത്തിരിഞ്ഞത് (വിഷയം)

എവിടെയാണ് ഉത്ഭവം/യജമാനൻ കമ്മിറ്റ് B3, B2, B1 എന്നിവയെ ചൂണ്ടിക്കാണിച്ചിരുന്നത്, ഇപ്പോൾ അത് B യിലും നിങ്ങളുടെ
ഉത്ഭവം/മാസ്റ്റർ B3-ൽ ആയിരുന്നപ്പോൾ ടോപ്പിക്ക് ബ്രാഞ്ച് അതിന്റെ മുകളിൽ ആരംഭിച്ചു. ഈ മോഡ് ഉപയോഗിക്കുന്നു
ബി 3 ഫോർക്ക് പോയിന്റായി കണ്ടെത്തുന്നതിന് ഒറിജിനിന്റെ/മാസ്റ്ററുടെ റിഫ്ലോഗ്, അതുവഴി വിഷയം പുനരാവിഷ്കരിക്കാനാകും
അപ്‌ഡേറ്റ് ചെയ്‌ത ഉത്ഭവം/മാസ്റ്ററിന് മുകളിൽ:

$ fork_point=$(git merge-base --fork-point origin/master topic)
$ git rebase --onto origin/master $fork_point topic

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് git-merge-base ഓൺലൈനായി ഉപയോഗിക്കുക