git-diff-index - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

git-diff-index - ഒരു വൃക്ഷത്തെ പ്രവർത്തിക്കുന്ന മരവുമായോ സൂചികയുമായോ താരതമ്യം ചെയ്യുക

സിനോപ്സിസ്

ജിറ്റിനെ വ്യത്യാസ സൂചിക [-m] [--കാഷെ ചെയ്‌തു] [ ] [ ...]

വിവരണം

ഒരു ട്രീ ഒബ്‌ജക്റ്റിൽ കാണപ്പെടുന്ന ബ്ലോബുകളുടെ ഉള്ളടക്കവും മോഡും അനുബന്ധവുമായി താരതമ്യം ചെയ്യുന്നു
പ്രവർത്തിക്കുന്ന ട്രീയിലെ ഫയലുകൾ ട്രാക്കുചെയ്‌തു, അല്ലെങ്കിൽ സൂചികയിലെ അനുബന്ധ പാതകൾക്കൊപ്പം. എപ്പോൾ
ആർഗ്യുമെന്റുകൾ നിലവിലുണ്ട്, ആ പാറ്റേണുകളുമായി പൊരുത്തപ്പെടുന്ന പാതകൾ മാത്രം താരതമ്യം ചെയ്യുന്നു. അല്ലെങ്കിൽ എല്ലാം
ട്രാക്ക് ചെയ്ത ഫയലുകൾ താരതമ്യം ചെയ്യുന്നു.

ഓപ്ഷനുകൾ

-p, -u, --patch
പാച്ച് ജനറേറ്റ് ചെയ്യുക (പാച്ചുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള വിഭാഗം കാണുക).

-s, --നോ-പാച്ച്
ഡിഫ് ഔട്ട്പുട്ട് അടിച്ചമർത്തുക. പാച്ച് കാണിക്കുന്ന ജിറ്റ് ഷോ പോലുള്ള കമാൻഡുകൾക്ക് ഉപയോഗപ്രദമാണ്
സ്ഥിരസ്ഥിതി, അല്ലെങ്കിൽ --patch ന്റെ പ്രഭാവം റദ്ദാക്കാൻ.

-യു , --unified=
ഉപയോഗിച്ച് വ്യത്യാസങ്ങൾ സൃഷ്ടിക്കുക സാധാരണ മൂന്നിന് പകരം സന്ദർഭത്തിന്റെ വരികൾ. സൂചിപ്പിക്കുന്നു -പി.

--റോ
റോ ഫോർമാറ്റിൽ വ്യത്യാസം സൃഷ്ടിക്കുക. ഇതാണ് സ്ഥിരസ്ഥിതി.

--പാച്ച്-വിത്ത്-റോ
-p --raw എന്നതിന്റെ പര്യായപദം.

--കുറഞ്ഞത്
സാധ്യമായ ഏറ്റവും ചെറിയ വ്യത്യാസം ഉൽപ്പാദിപ്പിക്കപ്പെടുന്നുവെന്ന് ഉറപ്പാക്കാൻ അധിക സമയം ചെലവഴിക്കുക.

--ക്ഷമ
"ക്ഷമ വ്യത്യാസം" അൽഗോരിതം ഉപയോഗിച്ച് ഒരു വ്യത്യാസം സൃഷ്ടിക്കുക.

--ഹിസ്റ്റോഗ്രാം
"ഹിസ്റ്റോഗ്രാം ഡിഫ്" അൽഗോരിതം ഉപയോഗിച്ച് ഒരു വ്യത്യാസം സൃഷ്ടിക്കുക.

--diff-algorithm={ക്ഷമ|മിനിമൽ|ഹിസ്റ്റോഗ്രാം|മയേഴ്സ്}
ഒരു ഡിഫ് അൽഗോരിതം തിരഞ്ഞെടുക്കുക. വകഭേദങ്ങൾ ഇപ്രകാരമാണ്:

സ്ഥിരസ്ഥിതി, myers
അടിസ്ഥാന അത്യാഗ്രഹ വ്യത്യാസം അൽഗോരിതം. നിലവിൽ, ഇതാണ് സ്ഥിരസ്ഥിതി.

ചുരുങ്ങിയ
സാധ്യമായ ഏറ്റവും ചെറിയ വ്യത്യാസം ഉൽപ്പാദിപ്പിക്കപ്പെടുന്നുവെന്ന് ഉറപ്പാക്കാൻ അധിക സമയം ചെലവഴിക്കുക.

ക്ഷമ
പാച്ചുകൾ സൃഷ്ടിക്കുമ്പോൾ "ക്ഷമ വ്യത്യാസം" അൽഗോരിതം ഉപയോഗിക്കുക.

ഹിസ്റ്റോഗ്രാം
ഈ അൽഗോരിതം ക്ഷമ അൽഗോരിതം വിപുലീകരിക്കുന്നത് "പൊതുവായ കുറവുകളെ പിന്തുണയ്ക്കുന്നു.
ഘടകങ്ങൾ".

ഉദാഹരണത്തിന്, നിങ്ങൾ ഡിഫോൾട്ട് അല്ലാത്ത മൂല്യത്തിലേക്ക് diff.algorithm വേരിയബിൾ കോൺഫിഗർ ചെയ്തിട്ടുണ്ടെങ്കിൽ ഒപ്പം
ഡിഫോൾട്ട് ഒന്ന് ഉപയോഗിക്കണമെങ്കിൽ --diff-algorithm=default ഓപ്ഷൻ ഉപയോഗിക്കണം.

--stat[= [, [, ]]]
ഒരു ഡിഫ്സ്റ്റാറ്റ് സൃഷ്ടിക്കുക. ഡിഫോൾട്ടായി, ആവശ്യമുള്ളത്ര സ്ഥലം ഇതിനായി ഉപയോഗിക്കും
ഫയലിന്റെ പേര് ഭാഗം, ബാക്കി ഗ്രാഫ് ഭാഗം. ടെർമിനലിലേക്കുള്ള പരമാവധി വീതി ഡിഫോൾട്ടുകൾ
വീതി, അല്ലെങ്കിൽ ഒരു ടെർമിനലുമായി ബന്ധിപ്പിച്ചിട്ടില്ലെങ്കിൽ 80 നിരകൾ, കൂടാതെ അസാധുവാക്കാനും കഴിയും .
മറ്റൊരു വീതി നൽകി ഫയൽനാമത്തിന്റെ ഭാഗത്തിന്റെ വീതി പരിമിതപ്പെടുത്താം
ഒരു കോമയ്ക്ക് ശേഷം. ഗ്രാഫ് ഭാഗത്തിന്റെ വീതി ഉപയോഗിച്ച് പരിമിതപ്പെടുത്താം
--stat-graph-width= (ഒരു സ്റ്റാറ്റ് ഗ്രാഫ് സൃഷ്ടിക്കുന്ന എല്ലാ കമാൻഡുകളെയും ബാധിക്കുന്നു) അല്ലെങ്കിൽ വഴി
ക്രമീകരണം diff.statGraphWidth= (ജിറ്റ് ഫോർമാറ്റ്-പാച്ചിനെ ബാധിക്കില്ല). ഒരു നൽകിക്കൊണ്ട്
മൂന്നാമത്തെ പരാമീറ്റർ , നിങ്ങൾക്ക് ഔട്ട്പുട്ട് ആദ്യത്തേതിലേക്ക് പരിമിതപ്പെടുത്താം വരികൾ, പിന്തുടരുന്നു
by ... കൂടുതൽ ഉണ്ടെങ്കിൽ.

ഈ പരാമീറ്ററുകൾ --stat-width= ഉപയോഗിച്ച് വ്യക്തിഗതമായി സജ്ജമാക്കാനും കഴിയും ,
--stat-name-width= കൂടാതെ --stat-count= .

--നംസ്റ്റാറ്റ്
--stat എന്നതിന് സമാനമാണ്, എന്നാൽ ദശാംശ നൊട്ടേഷനിൽ ചേർത്തതും ഇല്ലാതാക്കിയതുമായ വരികളുടെ എണ്ണം കാണിക്കുന്നു
കൂടുതൽ മെഷീൻ ഫ്രണ്ട്ലി ആക്കുന്നതിന്, ചുരുക്കെഴുത്തുകളില്ലാത്ത പാതയുടെ പേര്. ബൈനറി ഫയലുകൾക്കായി,
ഔട്ട്പുട്ട് രണ്ട് - 0 0 എന്ന് പറയുന്നതിന് പകരം.

--ഷോർട്ട്സ്റ്റാറ്റ്
പരിഷ്കരിച്ച മൊത്തം എണ്ണം അടങ്ങുന്ന --stat ഫോർമാറ്റിന്റെ അവസാന വരി മാത്രം ഔട്ട്പുട്ട് ചെയ്യുക
ഫയലുകൾ, കൂടാതെ ചേർത്തതും ഇല്ലാതാക്കിയതുമായ വരികളുടെ എണ്ണം.

--dirstat[= ]
ഓരോ ഉപ-ഡയറക്‌ടറിക്കുമുള്ള മാറ്റങ്ങളുടെ ആപേക്ഷിക തുകയുടെ വിതരണം ഔട്ട്‌പുട്ട് ചെയ്യുക. ദി
--dirstat-ന്റെ പെരുമാറ്റം കോമയാൽ വേർതിരിച്ച ലിസ്റ്റ് വഴി ഇച്ഛാനുസൃതമാക്കാം
പരാമീറ്ററുകൾ. ഡിഫോൾട്ടുകൾ നിയന്ത്രിക്കുന്നത് diff.dirstat കോൺഫിഗറേഷൻ വേരിയബിൾ ആണ്
(കാണുക git-config(1)). ഇനിപ്പറയുന്ന പാരാമീറ്ററുകൾ ലഭ്യമാണ്:

മാറ്റങ്ങൾ
എന്നതിൽ നിന്ന് നീക്കം ചെയ്‌ത വരികൾ എണ്ണി ഡയർസ്റ്റാറ്റ് നമ്പറുകൾ കണക്കാക്കുക
ഉറവിടം, അല്ലെങ്കിൽ ലക്ഷ്യസ്ഥാനത്തേക്ക് ചേർത്തു. ഇത് ശുദ്ധമായ കോഡിന്റെ അളവ് അവഗണിക്കുന്നു
ഒരു ഫയലിനുള്ളിലെ ചലനങ്ങൾ. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഒരു ഫയലിലെ വരികൾ പുനഃക്രമീകരിക്കുന്നത് അങ്ങനെയല്ല
മറ്റ് മാറ്റങ്ങൾ പോലെ കണക്കാക്കുന്നു. പരാമീറ്റർ ഇല്ലാത്തപ്പോൾ ഇതാണ് ഡിഫോൾട്ട് സ്വഭാവം
കൊടുത്തു.

ലൈനുകൾ
പതിവ് ലൈൻ അധിഷ്‌ഠിത ഡിഫ് വിശകലനം നടത്തി ഡിർസ്റ്റാറ്റ് നമ്പറുകൾ കണക്കാക്കുക, കൂടാതെ
നീക്കം ചെയ്ത/ചേർത്ത വരികളുടെ എണ്ണം സംഗ്രഹിക്കുന്നു. (ബൈനറി ഫയലുകൾക്കായി, 64-ബൈറ്റ് ഭാഗങ്ങൾ എണ്ണുക
പകരം, ബൈനറി ഫയലുകൾക്ക് ലൈനുകളുടെ സ്വാഭാവിക ആശയം ഇല്ലാത്തതിനാൽ). ഇത് കൂടുതലാണ്
ചെലവേറിയ --ഡിർസ്റ്റാറ്റ് സ്വഭാവം മാറ്റുന്ന സ്വഭാവത്തേക്കാൾ, പക്ഷേ അത് കണക്കാക്കുന്നു
മറ്റ് മാറ്റങ്ങൾ പോലെ ഒരു ഫയലിനുള്ളിലെ വരികൾ പുനഃക്രമീകരിച്ചു. തത്ഫലമായുണ്ടാകുന്ന ഔട്ട്പുട്ട് ആണ്
മറ്റ് --*സ്റ്റാറ്റ് ഓപ്ഷനുകളിൽ നിന്ന് നിങ്ങൾക്ക് ലഭിക്കുന്ന കാര്യങ്ങളുമായി പൊരുത്തപ്പെടുന്നു.

ഫയലുകൾ
മാറിയ ഫയലുകളുടെ എണ്ണം കണക്കാക്കി dirstat നമ്പറുകൾ കണക്കാക്കുക. ഓരോന്നും മാറി
dirstat വിശകലനത്തിൽ ഫയൽ തുല്യമായി കണക്കാക്കുന്നു. ഇതാണ് ഏറ്റവും വിലകുറഞ്ഞ കണക്കുകൂട്ടൽ
--dirstat സ്വഭാവം, അത് ഫയലിന്റെ ഉള്ളടക്കങ്ങൾ നോക്കേണ്ടതില്ല.

ക്യുമുലേറ്റീവ്
പാരന്റ് ഡയറക്‌ടറിക്ക് വേണ്ടിയും ചൈൽഡ് ഡയറക്‌ടറിയിലെ മാറ്റങ്ങൾ എണ്ണുക. അതല്ല
ക്യുമുലേറ്റീവ് ഉപയോഗിക്കുമ്പോൾ, റിപ്പോർട്ടുചെയ്ത ശതമാനങ്ങളുടെ ആകെത്തുക 100% കവിഞ്ഞേക്കാം. ദി
സ്വതവേയുള്ള (നോൺ-ക്യുമുലേറ്റീവ്) സ്വഭാവം നോൺ-ക്യുമുലേറ്റീവ് ഉപയോഗിച്ച് വ്യക്തമാക്കാം
പാരാമീറ്റർ.


ഒരു പൂർണ്ണസംഖ്യ പാരാമീറ്റർ ഒരു കട്ട്-ഓഫ് ശതമാനം വ്യക്തമാക്കുന്നു (സ്ഥിരസ്ഥിതിയായി 3%). ഡയറക്ടറികൾ
ഈ ശതമാനത്തിൽ കുറവ് സംഭാവന ചെയ്യുന്നത് ഔട്ട്പുട്ടിൽ കാണിക്കുന്നില്ല.

ഉദാഹരണം: കുറവ് ഡയറക്‌ടറികൾ അവഗണിക്കുമ്പോൾ, ഇനിപ്പറയുന്നവ മാറിയ ഫയലുകൾ കണക്കാക്കും
മാറ്റിയ ഫയലുകളുടെ ആകെ തുകയുടെ 10%-ലധികം, ചൈൽഡ് ഡയറക്‌ടറികളുടെ എണ്ണം
പാരന്റ് ഡയറക്‌ടറികളിൽ: --dirstat=files,10,cumulative.

--സംഗ്രഹം
സൃഷ്‌ടികൾ, പുനർനാമകരണങ്ങൾ തുടങ്ങിയ വിപുലീകൃത തലക്കെട്ട് വിവരങ്ങളുടെ ഒരു സംഗ്രഹം ഔട്ട്‌പുട്ട് ചെയ്യുക
കൂടാതെ മോഡ് മാറ്റങ്ങളും.

--patch-with-stat
-p --stat എന്നതിന്റെ പര്യായപദം.

-z
--raw, --numstat, --name-only അല്ലെങ്കിൽ --name-status നൽകിയിരിക്കുമ്പോൾ, മുങ്ങരുത്
പാത്ത് നെയിമുകളും ഔട്ട്പുട്ട് ഫീൽഡ് ടെർമിനേറ്ററുകളായി NUL-കളും ഉപയോഗിക്കുക.

ഈ ഓപ്‌ഷൻ കൂടാതെ, ഓരോ പാത്ത്‌നെയിം ഔട്ട്‌പുട്ടിലും TAB, LF, ഇരട്ട ഉദ്ധരണികൾ, കൂടാതെ ഉണ്ടായിരിക്കും
ബാക്ക്‌സ്ലാഷ് പ്രതീകങ്ങൾ യഥാക്രമം \t, \n, \", \\ എന്നിവ ഉപയോഗിച്ച് മാറ്റി, പാത്ത് നെയിം
അവയിൽ ഏതെങ്കിലും മാറ്റിസ്ഥാപിക്കുകയാണെങ്കിൽ ഇരട്ട ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തും.

--പേര് മാത്രം
മാറ്റിയ ഫയലുകളുടെ പേരുകൾ മാത്രം കാണിക്കുക.

--പേര്-നില
മാറ്റിയ ഫയലുകളുടെ പേരും സ്റ്റാറ്റസും മാത്രം കാണിക്കുക. --diff-filter-ന്റെ വിവരണം കാണുക
സ്റ്റാറ്റസ് അക്ഷരങ്ങൾ എന്താണ് അർത്ഥമാക്കുന്നത് എന്നതിനെക്കുറിച്ചുള്ള ഓപ്ഷൻ.

--ഉപമൊഡ്യൂൾ[= ]
സബ്മോഡ്യൂളുകളിലെ വ്യത്യാസങ്ങൾ എങ്ങനെയാണ് കാണിക്കുന്നതെന്ന് വ്യക്തമാക്കുക. എപ്പോൾ --submodule അല്ലെങ്കിൽ --submodule=log
നൽകിയിരിക്കുന്നു, ദി ലോഗ് ഫോർമാറ്റ് ഉപയോഗിക്കുന്നു. ഈ ഫോർമാറ്റ് ശ്രേണിയിലെ കമ്മിറ്റുകൾ ലിസ്റ്റ് ചെയ്യുന്നു git-
ഉപ മൊഡ്യൂൾ(1) സംഗ്രഹം ചെയ്യുന്നു. --submodule ഓപ്ഷൻ ഒഴിവാക്കുക അല്ലെങ്കിൽ വ്യക്തമാക്കുക
--submodule=short, ഉപയോഗിക്കുന്നു കുറിയ ഫോർമാറ്റ്. ഈ ഫോർമാറ്റ് അതിന്റെ പേരുകൾ കാണിക്കുന്നു
ശ്രേണിയുടെ തുടക്കത്തിലും അവസാനത്തിലും ചെയ്യുന്നു. diff.submodule വഴി ട്വീക്ക് ചെയ്യാം
കോൺഫിഗറേഷൻ വേരിയബിൾ.

--നിറം[= ]
നിറമുള്ള വ്യത്യാസം കാണിക്കുക. --നിറം (അതായത് ഇല്ലാതെ =) --color=എല്ലായ്പ്പോഴും എന്നതിന് സമാനമാണ്.
എപ്പോഴും, ഒരിക്കലും, അല്ലെങ്കിൽ സ്വയമേവ ഒന്നാകാം.

--നിറമില്ല
നിറമുള്ള വ്യത്യാസം ഓഫാക്കുക. ഇത് --നിറം=ഒരിക്കലും അല്ല.

--word-diff[= ]
ഉപയോഗിച്ച് ഒരു വാക്ക് വ്യത്യാസം കാണിക്കുക മാറിയ വാക്കുകളെ പരിമിതപ്പെടുത്താൻ. സ്ഥിരസ്ഥിതിയായി, വാക്കുകളാണ്
വൈറ്റ്‌സ്‌പെയ്‌സ് കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു; താഴെ --word-diff-regex കാണുക. ദി സ്ഥിരസ്ഥിതിയായി പ്ലെയിൻ,
കൂടാതെ ഇവയിലൊന്നായിരിക്കണം:

നിറം
മാറിയ വാക്കുകൾ നിറങ്ങൾ മാത്രം ഉപയോഗിച്ച് ഹൈലൈറ്റ് ചെയ്യുക. സൂചിപ്പിക്കുന്നു --നിറം.

പ്ലെയിൻ
വാക്കുകൾ [-നീക്കം ചെയ്‌തത്-], {+ ചേർത്തു+} എന്നിങ്ങനെ കാണിക്കുക. രക്ഷപ്പെടാൻ ഒരു ശ്രമവും നടത്തുന്നില്ല
ഡിലിമിറ്ററുകൾ ഇൻപുട്ടിൽ ദൃശ്യമാകുകയാണെങ്കിൽ, ഔട്ട്പുട്ട് അവ്യക്തമായിരിക്കാം.

കളിമൺ
സ്ക്രിപ്റ്റ് ഉപഭോഗത്തിനായി ഉദ്ദേശിച്ചിട്ടുള്ള ഒരു പ്രത്യേക ലൈൻ അടിസ്ഥാനമാക്കിയുള്ള ഫോർമാറ്റ് ഉപയോഗിക്കുക.
ചേർത്ത/നീക്കം ചെയ്ത/മാറ്റാത്ത റണ്ണുകൾ സാധാരണ ഏകീകൃത ഡിഫ് ഫോർമാറ്റിൽ പ്രിന്റ് ചെയ്യുന്നു,
വരിയുടെ തുടക്കത്തിൽ ഒരു +/-/`` അക്ഷരത്തിൽ ആരംഭിച്ച് നീളുന്നു
വരിയുടെ അവസാനം. ഇൻപുട്ടിലെ ന്യൂലൈനുകളെ ഒരു ലൈനിൽ ഒരു ടിൽഡ് ~ പ്രതിനിധീകരിക്കുന്നു
സ്വന്തമായി.

ആരും
വേഡ് ഡിഫ് വീണ്ടും പ്രവർത്തനരഹിതമാക്കുക.

ആദ്യ മോഡിന്റെ പേര് ഉണ്ടായിരുന്നിട്ടും, മാറിയത് ഹൈലൈറ്റ് ചെയ്യാൻ നിറം ഉപയോഗിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക
പ്രവർത്തനക്ഷമമാക്കിയാൽ എല്ലാ മോഡുകളിലും ഭാഗങ്ങൾ.

--word-diff-regex=
ഉപയോഗിക്കുക വൈറ്റ്‌സ്‌പേസ് അല്ലാത്ത റണ്ണുകൾ പരിഗണിക്കുന്നതിന് പകരം ഒരു വാക്ക് എന്താണെന്ന് തീരുമാനിക്കുക
ഒരു വാക്ക് ആകുക. കൂടാതെ --word-diff ഇത് ഇതിനകം പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ലെങ്കിൽ.

ഓവർലാപ്പുചെയ്യാത്ത എല്ലാ മത്സരങ്ങളും ഒരു വാക്കായി കണക്കാക്കുന്നു. തമ്മിൽ എന്തും
ഈ പൊരുത്തങ്ങൾ വൈറ്റ്‌സ്‌പെയ്‌സ് ആയി കണക്കാക്കുകയും കണ്ടെത്താനുള്ള ഉദ്ദേശ്യങ്ങൾക്കായി അവഗണിക്കുകയും ചെയ്യുന്നു(!).
വ്യത്യാസങ്ങൾ. നിങ്ങളുടെ പതിവ് എക്സ്പ്രഷനിലേക്ക് |[^[:space:]] കൂട്ടിച്ചേർക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം
ഇത് വൈറ്റ്‌സ്‌പേസ് ഇതര എല്ലാ പ്രതീകങ്ങളുമായും പൊരുത്തപ്പെടുന്നുണ്ടെന്ന് ഉറപ്പാണ്. ഒരു പുതിയ ലൈൻ ഉൾക്കൊള്ളുന്ന ഒരു പൊരുത്തം
ന്യൂലൈനിൽ നിശബ്ദമായി വെട്ടിച്ചുരുക്കി(!).

ഉദാഹരണത്തിന്, --word-diff-regex=. ഓരോ കഥാപാത്രത്തെയും ഒരു വാക്കായി പരിഗണിക്കും,
അതനുസരിച്ച്, സ്വഭാവം അനുസരിച്ച് വ്യത്യാസങ്ങൾ കാണിക്കുക.

ഒരു ഡിഫ് ഡ്രൈവർ അല്ലെങ്കിൽ കോൺഫിഗറേഷൻ ഓപ്ഷൻ വഴിയും regex സജ്ജമാക്കാൻ കഴിയും, കാണുക
ഗിറ്റാട്രിബ്യൂട്ടുകൾ(1) അല്ലെങ്കിൽ git-config(1). ഇത് നൽകുന്നത് ഏതെങ്കിലും ഡിഫ് ഡ്രൈവറെ വ്യക്തമായി മറികടക്കുന്നു അല്ലെങ്കിൽ
കോൺഫിഗറേഷൻ ക്രമീകരണം. ഡിഫ് ഡ്രൈവറുകൾ കോൺഫിഗറേഷൻ ക്രമീകരണങ്ങൾ അസാധുവാക്കുന്നു.

--നിറം-പദങ്ങൾ[= ]
--word-diff=color plus എന്നതിന് തുല്യം (ഒരു regex വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ)
--word-diff-regex= .

--ഇല്ല-പേരുകൾ
കോൺഫിഗറേഷൻ ഫയൽ ഡിഫോൾട്ട് ചെയ്യാൻ നൽകുമ്പോൾ പോലും, പേരുമാറ്റം കണ്ടെത്തൽ ഓഫാക്കുക
അങ്ങനെ.

--ചെക്ക്
മാറ്റങ്ങൾ വൈറ്റ്‌സ്‌പേസ് പിശകുകൾ അവതരിപ്പിക്കുകയാണെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക. വൈറ്റ്‌സ്‌പേസ് പിശകുകളായി കണക്കാക്കുന്നത്
core.whitespace കോൺഫിഗറേഷൻ വഴി നിയന്ത്രിക്കപ്പെടുന്നു. ഡിഫോൾട്ടായി, വൈറ്റ്‌സ്‌പെയ്‌സുകൾ പിന്തുടരുന്നു
(വെളുത്ത ഇടങ്ങൾ മാത്രം ഉൾക്കൊള്ളുന്ന വരികൾ ഉൾപ്പെടെ) കൂടാതെ ഒരു സ്പേസ് പ്രതീകവും
ഉടൻ തന്നെ വരിയുടെ പ്രാരംഭ ഇൻഡന്റിനുള്ളിൽ ഒരു ടാബ് പ്രതീകം ഉണ്ട്
വൈറ്റ്‌സ്‌പേസ് പിശകുകളായി കണക്കാക്കുന്നു. പ്രശ്‌നങ്ങൾ കണ്ടെത്തിയാൽ പൂജ്യമല്ലാത്ത നിലയോടെ പുറത്തുകടക്കുന്നു. അല്ല
--എക്സിറ്റ്-കോഡുമായി പൊരുത്തപ്പെടുന്നു.

--ws-error-highlight=
വ്യക്തമാക്കിയ ലൈനുകളിൽ വൈറ്റ്‌സ്‌പേസ് പിശകുകൾ ഹൈലൈറ്റ് ചെയ്യുക വ്യക്തമാക്കിയ നിറത്തിൽ
color.diff.whitespace. പഴയത്, പുതിയത്, സന്ദർഭം എന്നിവയുടെ കോമ വേർതിരിക്കപ്പെട്ട പട്ടികയാണ്. എപ്പോൾ
ഈ ഓപ്‌ഷൻ നൽകിയിട്ടില്ല, പുതിയ ലൈനുകളിലെ വൈറ്റ്‌സ്‌പേസ് പിശകുകൾ മാത്രമാണ് ഹൈലൈറ്റ് ചെയ്യുന്നത്. ഉദാ
--ws-error-highlight=പുതിയത്, പഴയത് ഇല്ലാതാക്കിയതും ചേർത്തതുമായ വൈറ്റ്‌സ്‌പേസ് പിശകുകൾ ഹൈലൈറ്റ് ചെയ്യുന്നു
ലൈനുകൾ. പഴയത്, പുതിയത്, സന്ദർഭം എന്നിവയ്ക്കായി എല്ലാം ഒരു ഹ്രസ്വ കൈയായി ഉപയോഗിക്കാം.

--പൂർണ്ണ സൂചിക
ആദ്യത്തെ പിടി പ്രതീകങ്ങൾക്ക് പകരം, ചിത്രത്തിന് മുമ്പും ശേഷവും പൂർണ്ണമായ ബ്ലബ് കാണിക്കുക
പാച്ച് ഫോർമാറ്റ് ഔട്ട്പുട്ട് സൃഷ്ടിക്കുമ്പോൾ "ഇൻഡക്സ്" ലൈനിൽ ഒബ്ജക്റ്റ് പേരുകൾ.

--ബൈനറി
--full-index-ന് പുറമേ, git-apply ഉപയോഗിച്ച് പ്രയോഗിക്കാൻ കഴിയുന്ന ഒരു ബൈനറി വ്യത്യാസം ഔട്ട്പുട്ട് ചെയ്യുക.

--ചുരുക്കം[= ]
40-ബൈറ്റ് ഹെക്‌സാഡെസിമൽ ഒബ്‌ജക്റ്റ് നാമം ഡിഫ്-റോ ഫോർമാറ്റ് ഔട്ട്‌പുട്ടിൽ കാണിക്കുന്നതിന് പകരം
കൂടാതെ ഡിഫ്-ട്രീ ഹെഡർ ലൈനുകളും, ഒരു ഭാഗിക പ്രിഫിക്‌സ് മാത്രം കാണിക്കുക. ഇത് സ്വതന്ത്രമാണ്
മുകളിലുള്ള --full-index ഓപ്ഷൻ, അത് diff-patch ഔട്ട്പുട്ട് ഫോർമാറ്റ് നിയന്ത്രിക്കുന്നു. സ്ഥിരസ്ഥിതിയല്ല
അക്കങ്ങളുടെ എണ്ണം --abbrev= ഉപയോഗിച്ച് വ്യക്തമാക്കാം .

-ബി[ ][/ ], --break-rewrites[=[ ][/ ]]
പൂർണ്ണമായ റീറൈറ്റ് മാറ്റങ്ങളെ ഡിലീറ്റ് ജോഡികളായി വിഭജിച്ച് സൃഷ്ടിക്കുക. ഇത് രണ്ടെണ്ണം നൽകുന്നു
ഉദ്ദേശ്യങ്ങൾ:

ഒരു സീരീസായിട്ടല്ല ഒരു ഫയലിന്റെ മൊത്തത്തിലുള്ള റീറൈറ്റിനു തുല്യമായ മാറ്റത്തെ ഇത് ബാധിക്കുന്നു
ഇല്ലാതാക്കലും ചേർക്കലും തമ്മിൽ പൊരുത്തപ്പെടുന്ന വളരെ കുറച്ച് വരികൾ കൂടിച്ചേർന്നതാണ്
വാചകപരമായി സന്ദർഭം പോലെ, എന്നാൽ പഴയതെല്ലാം ഒറ്റത്തവണ ഇല്ലാതാക്കി തുടർന്ന് a
പുതിയ എല്ലാത്തിന്റെയും ഒറ്റ ഇൻസെർഷൻ, കൂടാതെ m എന്ന സംഖ്യ -B യുടെ ഈ വശം നിയന്ത്രിക്കുന്നു
ഓപ്ഷൻ (സ്ഥിരസ്ഥിതി 60% വരെ). -B/70%, ഒറിജിനലിന്റെ 30%-ൽ കുറവായിരിക്കണമെന്ന് വ്യക്തമാക്കുന്നു
Git ന്റെ ഫലത്തിൽ തന്നെ തുടരുക, ഇത് ഒരു മൊത്തത്തിലുള്ള തിരുത്തിയെഴുതിയതായി കണക്കാക്കുന്നു (അതായത്
തത്ഫലമായുണ്ടാകുന്ന പാച്ച്, സന്ദർഭവുമായി കൂടിച്ചേർന്ന ഇല്ലാതാക്കലിന്റെയും ഉൾപ്പെടുത്തലിന്റെയും ഒരു പരമ്പരയായിരിക്കും
ലൈനുകൾ).

-M ഉപയോഗിച്ച് ഉപയോഗിക്കുമ്പോൾ, പൂർണ്ണമായും മാറ്റിയെഴുതിയ ഫയലും a യുടെ ഉറവിടമായി കണക്കാക്കപ്പെടുന്നു
പേരുമാറ്റുക (സാധാരണയായി -M ഒരു പുനർനാമകരണത്തിന്റെ ഉറവിടമായി അപ്രത്യക്ഷമായ ഒരു ഫയലിനെ മാത്രമേ പരിഗണിക്കുകയുള്ളൂ),
കൂടാതെ നമ്പർ n -B ഓപ്ഷന്റെ ഈ വശം നിയന്ത്രിക്കുന്നു (സ്ഥിരസ്ഥിതി 50% വരെ). -B20%
20% അല്ലെങ്കിൽ അതിൽ കൂടുതലുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ കൂട്ടിച്ചേർക്കലും ഇല്ലാതാക്കലും ഉള്ള ഒരു മാറ്റം വ്യക്തമാക്കുന്നു
ഫയലിന്റെ വലുപ്പം എന്നതിലേക്ക് പുനർനാമകരണം സാധ്യമായ ഉറവിടമായി എടുക്കുന്നതിന് യോഗ്യമാണ്
മറ്റൊരു ഫയൽ.

-എം[ ], --find-renames[= ]
പേരുമാറ്റങ്ങൾ കണ്ടെത്തുക. n വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, അത് സമാനത സൂചികയിലെ ഒരു പരിധിയാണ് (അതായത്
ഫയലിന്റെ വലുപ്പവുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ കൂട്ടിച്ചേർക്കലിന്റെ/ഇല്ലാതാക്കലുകളുടെ അളവ്). ഉദാഹരണത്തിന്, -M90% അർത്ഥമാക്കുന്നത്
ഫയലിന്റെ 90%-ൽ കൂടുതലാണെങ്കിൽ, ഒരു ഡിലീറ്റ്/ആഡ് ജോഡി പുനർനാമകരണമായി Git പരിഗണിക്കണം
മാറിയിട്ടില്ല. % ചിഹ്നമില്ലാതെ, സംഖ്യ ഒരു ഭിന്നസംഖ്യയായി വായിക്കണം, a
അതിന് മുമ്പുള്ള ദശാംശ പോയിന്റ്. അതായത്, -M5 0.5 ആയി മാറുന്നു, അതിനാൽ -M50% ന് തുല്യമാണ്.
അതുപോലെ, -M05 എന്നത് -M5% ആണ്. കൃത്യമായ പേരുമാറ്റങ്ങളിലേക്ക് കണ്ടെത്തൽ പരിമിതപ്പെടുത്താൻ, -M100% ഉപയോഗിക്കുക.
സ്ഥിരസ്ഥിതി സമാനത സൂചിക 50% ആണ്.

-സി[ ], --കണ്ടെത്തുക-പകർപ്പുകൾ[= ]
പകർപ്പുകളും പേരുമാറ്റങ്ങളും കണ്ടെത്തുക. ഇതും കാണുക --ഫൈൻഡ്-കോപ്പികൾ-ഹാർഡർ. n വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, അത്
-M എന്നതിന് സമാനമായ അർത്ഥമുണ്ട് .

--കണ്ടെത്തുക-പകർപ്പുകൾ-കാഠിന്യം
പ്രകടന കാരണങ്ങളാൽ, സ്ഥിരസ്ഥിതിയായി, -C ഓപ്ഷൻ യഥാർത്ഥ ഫയൽ ആണെങ്കിൽ മാത്രമേ പകർപ്പുകൾ കണ്ടെത്തൂ
പകർപ്പിന്റെ അതേ മാറ്റങ്ങളിൽ മാറ്റം വരുത്തി. ഈ ഫ്ലാഗ് കമാൻഡിനെ പരിശോധിക്കുന്നു
പകർപ്പിന്റെ ഉറവിടത്തിനായുള്ള സ്ഥാനാർത്ഥികളായി മാറ്റാത്ത ഫയലുകൾ. ഇത് വളരെ ചെലവേറിയതാണ്
വലിയ പദ്ധതികൾക്കുള്ള പ്രവർത്തനം, അതിനാൽ ഇത് ജാഗ്രതയോടെ ഉപയോഗിക്കുക. ഒന്നിൽ കൂടുതൽ -C ഓപ്ഷനുകൾ നൽകുന്നു
അതേ പ്രഭാവം ഉണ്ട്.

-ഡി, --തിരിച്ചറിയാം-ഇല്ലാതാക്കുക
ഇല്ലാതാക്കലുകൾക്കായി പ്രിമേജ് ഒഴിവാക്കുക, അതായത് ഹെഡ്ഡർ മാത്രം പ്രിന്റ് ചെയ്യുക, എന്നാൽ ഇവ തമ്മിലുള്ള വ്യത്യാസം പാടില്ല
preimage കൂടാതെ /dev/null. തത്ഫലമായുണ്ടാകുന്ന പാച്ച് പാച്ച് ഉപയോഗിച്ച് പ്രയോഗിക്കാൻ ഉദ്ദേശിച്ചുള്ളതല്ല അല്ലെങ്കിൽ
git പ്രയോഗിക്കുക; ഇത് അവലോകനം ചെയ്യുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ ആഗ്രഹിക്കുന്ന ആളുകൾക്ക് മാത്രമുള്ളതാണ്
മാറ്റത്തിന് ശേഷം വാചകം. കൂടാതെ, ഔട്ട്പുട്ടിൽ വേണ്ടത്ര വിവരങ്ങൾ ഇല്ല
അത്തരമൊരു പാച്ച് റിവേഴ്‌സിൽ പ്രയോഗിക്കുക, സ്വമേധയാ പോലും, അതിനാൽ ഓപ്ഷന്റെ പേര്.

-B-യ്‌ക്കൊപ്പം ഉപയോഗിക്കുമ്പോൾ, a-യുടെ ഇല്ലാതാക്കൽ ഭാഗത്തിലെ മുൻചിത്രവും ഒഴിവാക്കുക
ജോഡി ഇല്ലാതാക്കുക/സൃഷ്ടിക്കുക.

-എൽ
-M, -C ഓപ്ഷനുകൾക്ക് O(n^2) പ്രോസസ്സിംഗ് സമയം ആവശ്യമാണ്, ഇവിടെ n എന്നതിന്റെ സംഖ്യയാണ്
സാധ്യതയുള്ള പുനർനാമകരണം/പകർത്തൽ ലക്ഷ്യങ്ങൾ. ഈ ഓപ്‌ഷൻ പുനർനാമകരണം/പകർപ്പ് കണ്ടെത്തൽ പ്രവർത്തിക്കുന്നതിൽ നിന്ന് തടയുന്നു
പുനർനാമകരണം/പകർത്തൽ ടാർഗെറ്റുകളുടെ എണ്ണം നിർദ്ദിഷ്ട സംഖ്യയിൽ കൂടുതലാണെങ്കിൽ.

--diff-filter=[(A|C|D|M|R|T|U|X|B)...[*]]
ചേർത്ത (A), പകർത്തിയ (C), ഇല്ലാതാക്കിയ (D), പരിഷ്കരിച്ച (M), പേരുമാറ്റിയ ഫയലുകൾ മാത്രം തിരഞ്ഞെടുക്കുക
(R), അവയുടെ തരം (അതായത് റെഗുലർ ഫയൽ, സിംലിങ്ക്, സബ്മോഡ്യൂൾ, ...) മാറ്റിയിരിക്കുന്നു (T),
ലയിപ്പിക്കാത്തത് (U), അജ്ഞാതമാണ് (X), അല്ലെങ്കിൽ അവയുടെ ജോടിയാക്കൽ തകർന്നിരിക്കുന്നു (B). ഏതെങ്കിലും കോമ്പിനേഷൻ
ഫിൽട്ടർ പ്രതീകങ്ങളുടെ (ഒന്നുമില്ല ഉൾപ്പെടെ) ഉപയോഗിക്കാൻ കഴിയും. * (എല്ലാം അല്ലെങ്കിൽ ഒന്നുമില്ല) ചേർക്കുമ്പോൾ
കോമ്പിനേഷനിലേക്ക്, മറ്റുള്ളവയുമായി പൊരുത്തപ്പെടുന്ന ഏതെങ്കിലും ഫയൽ ഉണ്ടെങ്കിൽ എല്ലാ പാതകളും തിരഞ്ഞെടുക്കും
താരതമ്യത്തിലെ മാനദണ്ഡം; മറ്റ് മാനദണ്ഡങ്ങളുമായി പൊരുത്തപ്പെടുന്ന ഒരു ഫയലും ഇല്ലെങ്കിൽ, ഒന്നുമില്ല
തിരഞ്ഞെടുത്തു.

-എസ്
നിർദ്ദിഷ്ട സ്ട്രിംഗിന്റെ സംഭവങ്ങളുടെ എണ്ണം മാറ്റുന്ന വ്യത്യാസങ്ങൾക്കായി നോക്കുക
(അതായത് കൂട്ടിച്ചേർക്കൽ/ഇല്ലാതാക്കൽ) ഒരു ഫയലിൽ. സ്ക്രിപ്റ്ററിന്റെ ഉപയോഗത്തിനായി ഉദ്ദേശിച്ചുള്ളതാണ്.

നിങ്ങൾ കോഡിന്റെ കൃത്യമായ ബ്ലോക്ക് (സ്‌ട്രക്‌റ്റ് പോലെ) തിരയുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്
ആ ബ്ലോക്ക് നിലവിൽ വന്നതു മുതലുള്ള ചരിത്രം അറിയാൻ: ഫീച്ചർ ഉപയോഗിക്കുക
ആവർത്തിച്ച് പ്രിമേജിലെ രസകരമായ ബ്ലോക്ക് -S-ലേക്ക് തിരികെ നൽകുകയും തുടരുകയും ചെയ്യുക
ബ്ലോക്കിന്റെ ആദ്യ പതിപ്പ് ലഭിക്കുന്നതുവരെ.

-ജി
പാച്ച് ടെക്‌സ്‌റ്റിൽ പൊരുത്തപ്പെടുന്ന വരികൾ ചേർത്ത/നീക്കം ചെയ്‌ത വ്യത്യാസങ്ങൾക്കായി നോക്കുക .

-എസ് തമ്മിലുള്ള വ്യത്യാസം വ്യക്തമാക്കുന്നതിന് --pikaxe-regex, -G , പരിഗണിക്കുക
ഒരേ ഫയലിൽ ഇനിപ്പറയുന്ന വ്യത്യാസമുള്ള പ്രതിബദ്ധത:

+ റിട്ടേൺ !regexec(regexp, two->ptr, 1, ®match, 0);
...
- ഹിറ്റ് = !regexec(regexp, mf2.ptr, 1, ®match, 0);

git log -G"regexec\(regexp" ഈ പ്രതിബദ്ധത കാണിക്കുമ്പോൾ, git log -S"regexec\(regexp"
--pikaxe-regex ചെയ്യില്ല (കാരണം ആ സ്ട്രിംഗിന്റെ സംഭവങ്ങളുടെ എണ്ണം ഇല്ല
മാറ്റം).

കാണുക പിക്കാക്സ് പ്രവേശനം gitdiffcore(7) കൂടുതൽ വിവരങ്ങൾക്ക്.

--പിക്കാക്സ്-എല്ലാം
-S അല്ലെങ്കിൽ -G ഒരു മാറ്റം കണ്ടെത്തുമ്പോൾ, ആ മാറ്റങ്ങളിൽ മാത്രമല്ല, എല്ലാ മാറ്റങ്ങളും കാണിക്കുക
മാറ്റം ഉൾക്കൊള്ളുന്ന ഫയലുകൾ .

--pikaxe-regex
ചികിത്സിക്കുക പൊരുത്തപ്പെടുത്തുന്നതിന് വിപുലീകൃത POSIX റെഗുലർ എക്‌സ്‌പ്രഷനായി -S-ന് നൽകിയിരിക്കുന്നു.

-ഒ
ൽ വ്യക്തമാക്കിയ ക്രമത്തിൽ പാച്ച് ഔട്ട്പുട്ട് ചെയ്യുക , അതിന് ഒരു ഷെൽ ഗ്ലോബ് ഉണ്ട്
ഓരോ വരിയിലും പാറ്റേൺ. ഇത് diff.orderFile കോൺഫിഗറേഷൻ വേരിയബിളിനെ അസാധുവാക്കുന്നു (കാണുക git-
config(1)). diff.orderFile റദ്ദാക്കാൻ, -O/dev/null ഉപയോഗിക്കുക.

-R
രണ്ട് ഇൻപുട്ടുകൾ സ്വാപ്പ് ചെയ്യുക; അതായത്, ഇൻഡെക്സ് അല്ലെങ്കിൽ ഓൺ-ഡിസ്ക് ഫയലിൽ നിന്ന് ട്രീയിലേക്കുള്ള വ്യത്യാസങ്ങൾ കാണിക്കുക
ഉള്ളടക്കങ്ങൾ.

--ബന്ധു[= ]
പ്രോജക്റ്റിന്റെ ഒരു ഉപഡയറക്‌ടറിയിൽ നിന്ന് പ്രവർത്തിപ്പിക്കുമ്പോൾ, പുറത്തുള്ള മാറ്റങ്ങൾ ഒഴിവാക്കണമെന്ന് പറയാനാകും
ഈ ഓപ്‌ഷൻ ഉപയോഗിച്ച് ഡയറക്‌ടറിയും അതുമായി ബന്ധപ്പെട്ട പാതനാമങ്ങളും കാണിക്കുക. നിങ്ങൾ അകത്തില്ലാത്തപ്പോൾ
ഒരു ഉപഡയറക്‌ടറി (ഉദാഹരണത്തിന്, ഒരു വെറും ശേഖരത്തിൽ), ഏത് ഉപഡയറക്‌ടറിയാണ് നിർമ്മിക്കേണ്ടതെന്ന് നിങ്ങൾക്ക് പേരിടാം
നൽകുന്നതിലൂടെ ആപേക്ഷിക ഔട്ട്പുട്ട് ഒരു വാദമായി.

-a, --text
എല്ലാ ഫയലുകളും വാചകമായി പരിഗണിക്കുക.

--ഇഗ്നോർ-സ്പേസ്-അറ്റ്-ഇയോൾ
EOL-ൽ വൈറ്റ്‌സ്‌പെയ്‌സിലെ മാറ്റങ്ങൾ അവഗണിക്കുക.

-b, --ഇഗ്നോർ-സ്പേസ്-ചേഞ്ച്
വൈറ്റ്‌സ്‌പെയ്‌സിന്റെ അളവിലെ മാറ്റങ്ങൾ അവഗണിക്കുക. ഇത് ലൈൻ അറ്റത്തുള്ള വൈറ്റ്‌സ്‌പേസിനെ അവഗണിക്കുന്നു, ഒപ്പം
ഒന്നോ അതിലധികമോ വൈറ്റ്‌സ്‌പേസ് പ്രതീകങ്ങളുടെ മറ്റെല്ലാ സീക്വൻസുകളും തുല്യമായി കണക്കാക്കുന്നു.

-w, --ഓൾ-സ്പേസ് അവഗണിക്കുക
വരികൾ താരതമ്യം ചെയ്യുമ്പോൾ വൈറ്റ്‌സ്‌പേസ് അവഗണിക്കുക. ഒരു വരി ഉണ്ടെങ്കിലും ഇത് വ്യത്യാസങ്ങളെ അവഗണിക്കുന്നു
മറ്റേ ലൈനിൽ ഒന്നുമില്ലാത്ത വൈറ്റ്‌സ്‌പേസ്.

--ബ്ലാങ്ക്-ലൈനുകൾ അവഗണിക്കുക
എല്ലാ വരികളും ശൂന്യമായ മാറ്റങ്ങൾ അവഗണിക്കുക.

--inter-hunk-context=
വ്യത്യസ്‌ത ഹങ്കുകൾക്കിടയിലുള്ള സന്ദർഭം, അതിലൂടെ നിർദ്ദിഷ്ട വരികളുടെ എണ്ണം വരെ കാണിക്കുക
പരസ്പരം അടുത്തിരിക്കുന്ന ഹുങ്കുകൾ സംയോജിപ്പിക്കുന്നു.

-W, --ഫംഗ്ഷൻ-സന്ദർഭം
മാറ്റങ്ങളുടെ ചുറ്റുമുള്ള മുഴുവൻ പ്രവർത്തനങ്ങളും കാണിക്കുക.

--എക്സിറ്റ്-കോഡ്
സമാനമായ കോഡുകൾ ഉപയോഗിച്ച് പ്രോഗ്രാം പുറത്തുകടക്കുക ഡിഫ്എഫ്(1). അതായത്, 1 ഉണ്ടെങ്കിൽ അത് പുറത്തുകടക്കുന്നു
വ്യത്യാസങ്ങളായിരുന്നു, 0 എന്നാൽ വ്യത്യാസമില്ല.

--നിശബ്ദമായി
പ്രോഗ്രാമിന്റെ എല്ലാ ഔട്ട്പുട്ടും പ്രവർത്തനരഹിതമാക്കുക. --എക്സിറ്റ്-കോഡ് സൂചിപ്പിക്കുന്നു.

--എക്സ്റ്റ്-ഡിഫ്
എക്‌സ്‌റ്റേണൽ ഡിഫ് ഹെൽപ്പർ എക്‌സിക്യൂട്ട് ചെയ്യാൻ അനുവദിക്കുക. നിങ്ങൾ ഒരു ബാഹ്യ ഡിഫ് ഡ്രൈവർ സജ്ജീകരിക്കുകയാണെങ്കിൽ
ഗിറ്റാട്രിബ്യൂട്ടുകൾ(5), നിങ്ങൾ ഈ ഓപ്ഷൻ ഉപയോഗിക്കേണ്ടതുണ്ട് git-log(1) സുഹൃത്തുക്കളും.

--നോ-എക്സ്റ്റ്-ഡിഫ്
ബാഹ്യ ഡിഫ് ഡ്രൈവറുകൾ അനുവദിക്കരുത്.

--textconv, --no-textconv
ബൈനറി താരതമ്യം ചെയ്യുമ്പോൾ ബാഹ്യ ടെക്സ്റ്റ് കൺവേർഷൻ ഫിൽട്ടറുകൾ പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുക (അല്ലെങ്കിൽ അനുവദിക്കരുത്).
ഫയലുകൾ. കാണുക ഗിറ്റാട്രിബ്യൂട്ടുകൾ(5) വിശദാംശങ്ങൾക്ക്. കാരണം ടെക്സ്റ്റ് കോൺവ് ഫിൽട്ടറുകൾ സാധാരണയായി എ
വൺ-വേ പരിവർത്തനം, തത്ഫലമായുണ്ടാകുന്ന വ്യത്യാസം മനുഷ്യ ഉപഭോഗത്തിന് അനുയോജ്യമാണ്, പക്ഷേ കഴിയില്ല
പ്രയോഗിക്കും. ഇക്കാരണത്താൽ, textconv ഫിൽട്ടറുകൾ സ്ഥിരസ്ഥിതിയായി പ്രവർത്തനക്ഷമമാക്കിയിരിക്കുന്നു git-
ഡിഫ്എഫ്(1) ഉം git-log(1), പക്ഷേ വേണ്ടിയല്ല git-format-patch(1) അല്ലെങ്കിൽ ഡിഫ് പ്ലംബിംഗ് കമാൻഡുകൾ.

--ഇഗ്നോർ-സബ്മോഡ്യൂളുകൾ[= ]
ഡിഫ് ജനറേഷനിൽ സബ്‌മോഡ്യൂളുകളിലെ മാറ്റങ്ങൾ അവഗണിക്കുക. ഒന്നുകിൽ "ഒന്നുമില്ല" ആകാം,
"ട്രാക്ക് ചെയ്യപ്പെടാത്തത്", "വൃത്തികെട്ടത്" അല്ലെങ്കിൽ "എല്ലാം", ഇത് സ്ഥിരസ്ഥിതിയാണ്. "ഒന്നുമില്ല" ഉപയോഗിക്കുന്നത് പരിഗണിക്കും
ട്രാക്ക് ചെയ്യാത്തതോ പരിഷ്കരിച്ചതോ ആയ ഫയലുകൾ അല്ലെങ്കിൽ അതിന്റെ ഹെഡ് അടങ്ങിയിരിക്കുമ്പോൾ സബ്മോഡ്യൂൾ പരിഷ്ക്കരിച്ചു
സൂപ്പർ പ്രോജക്‌റ്റിൽ രേഖപ്പെടുത്തിയിരിക്കുന്ന പ്രതിബദ്ധതയിൽ നിന്ന് വ്യത്യസ്തമാണ്, ഏത് അസാധുവാക്കാനും ഇത് ഉപയോഗിക്കാം
യുടെ ക്രമീകരണങ്ങൾ അവഗണിക്കുക ഓപ്ഷൻ git-config(1) അല്ലെങ്കിൽ gitmodules(5) "ട്രാക്ക് ചെയ്യപ്പെടാത്തത്" ആയിരിക്കുമ്പോൾ
ഉപയോഗിച്ച സബ്‌മോഡ്യൂളുകളിൽ ട്രാക്ക് ചെയ്യാത്ത ഉള്ളടക്കം മാത്രം അടങ്ങിയിരിക്കുമ്പോൾ അവ വൃത്തികെട്ടതായി കണക്കാക്കില്ല (പക്ഷേ
പരിഷ്കരിച്ച ഉള്ളടക്കത്തിനായി അവ ഇപ്പോഴും സ്കാൻ ചെയ്യുന്നു). "വൃത്തികെട്ട" ഉപയോഗിക്കുന്നത് എല്ലാ മാറ്റങ്ങളും അവഗണിക്കുന്നു
സബ്‌മോഡ്യൂളുകളുടെ വർക്ക് ട്രീ, സൂപ്പർ പ്രോജക്‌റ്റിൽ സംഭരിച്ചിരിക്കുന്ന കമ്മിറ്റുകളിലെ മാറ്റങ്ങൾ മാത്രമാണ്
കാണിച്ചിരിക്കുന്നു (1.7.0 വരെയുള്ള പെരുമാറ്റം ഇതായിരുന്നു). "എല്ലാം" ഉപയോഗിക്കുന്നത് എല്ലാ മാറ്റങ്ങളും മറയ്ക്കുന്നു
ഉപഘടകങ്ങൾ.

--src-prefix=
"a/" എന്നതിന് പകരം നൽകിയിരിക്കുന്ന ഉറവിട പ്രിഫിക്‌സ് കാണിക്കുക.

--dst-prefix=
"b/" എന്നതിന് പകരം നൽകിയിരിക്കുന്ന ലക്ഷ്യസ്ഥാന പ്രിഫിക്‌സ് കാണിക്കുക.

--നോ-പ്രിഫിക്സ്
ഏതെങ്കിലും ഉറവിടമോ ലക്ഷ്യസ്ഥാന പ്രിഫിക്സോ കാണിക്കരുത്.

ഈ പൊതുവായ ഓപ്ഷനുകളെക്കുറിച്ചുള്ള കൂടുതൽ വിശദമായ വിശദീകരണത്തിന്, ഇതും കാണുക gitdiffcore(7).


വ്യത്യസ്‌തമാക്കേണ്ട ഒരു ട്രീ ഒബ്‌ജക്‌റ്റിന്റെ ഐഡി.

--കാഷ് ചെയ്തു
ഓൺ-ഡിസ്ക് ഫയൽ പരിഗണിക്കരുത്

-m
സ്ഥിരസ്ഥിതിയായി, സൂചികയിൽ റെക്കോർഡ് ചെയ്‌തതും എന്നാൽ ചെക്ക് ഔട്ട് ചെയ്യാത്തതുമായ ഫയലുകൾ ഇല്ലാതാക്കിയതായി റിപ്പോർട്ട് ചെയ്യപ്പെടും.
ഈ പതാക ഉണ്ടാക്കുന്നു ജിറ്റിനെ വ്യത്യാസ സൂചിക പരിശോധിക്കാത്ത എല്ലാ ഫയലുകളും കാലികമാണെന്ന് പറയുക.

റോ ഔട്ട്പ് ഫോർമാറ്റ്

"git-diff-index", "git-diff-tree", "git-diff-files", "git" എന്നിവയിൽ നിന്നുള്ള റോ ഔട്ട്പുട്ട് ഫോർമാറ്റ്
diff --raw" വളരെ സാമ്യമുള്ളവയാണ്.

ഈ കമാൻഡുകൾ എല്ലാം രണ്ട് സെറ്റ് കാര്യങ്ങളെ താരതമ്യം ചെയ്യുന്നു; താരതമ്യം ചെയ്യുന്നത് വ്യത്യസ്തമാണ്:

git-diff-index
താരതമ്യം ചെയ്യുന്നു കൂടാതെ ഫയൽസിസ്റ്റത്തിലെ ഫയലുകളും.

git-diff-index --കാഷെഡ്
താരതമ്യം ചെയ്യുന്നു സൂചികയും.

git-diff-tree [-r] [ ...]
രണ്ട് വാദങ്ങളാൽ പേരിട്ടിരിക്കുന്ന മരങ്ങളെ താരതമ്യം ചെയ്യുന്നു.

git-diff-files [ ...]
ഇൻഡക്സും ഫയൽസിസ്റ്റത്തിലെ ഫയലുകളും താരതമ്യം ചെയ്യുന്നു.

"git-diff-tree" കമാൻഡ് അതിന്റെ ഔട്ട്പുട്ട് ആരംഭിക്കുന്നത് എന്തായിരിക്കുന്നതിന്റെ ഹാഷ് പ്രിന്റ് ചെയ്തുകൊണ്ടാണ്
താരതമ്യം ചെയ്തു. അതിനുശേഷം, എല്ലാ കമാൻഡുകളും മാറ്റിയ ഫയലിന് ഒരു ഔട്ട്പുട്ട് ലൈൻ പ്രിന്റ് ചെയ്യുന്നു.

ഒരു ഔട്ട്പുട്ട് ലൈൻ ഈ രീതിയിൽ ഫോർമാറ്റ് ചെയ്തിരിക്കുന്നു:

ഇൻ-പ്ലേസ് എഡിറ്റ് :100644 100644 bcd1234... 0123456... M file0
copy-edit :100644 100644 abcd123... 1234567... C68 file1 file2
rename-edit :100644 100644 abcd123... 1234567... R86 file1 file3
സൃഷ്ടിക്കുക :000000 100644 0000000... 1234567... ഒരു ഫയൽ4
delete :100644 000000 1234567... 0000000... D file5
unmerged :000000 000000 0000000... 0000000... U file6

അതായത്, ഇടത്തുനിന്ന് വലത്തോട്ട്:

1. ഒരു കോളൻ.

2. "src" എന്നതിനുള്ള മോഡ്; സൃഷ്‌ടിക്കുകയോ ലയിപ്പിക്കാതിരിക്കുകയോ ചെയ്‌താൽ 000000.

3. ഒരു ഇടം.

4. "dst" എന്നതിനുള്ള മോഡ്; ഇല്ലാതാക്കുകയോ ലയിപ്പിക്കാതിരിക്കുകയോ ചെയ്താൽ 000000.

5. ഒരു ഇടം.

6. "src" എന്നതിനുള്ള sha1; സൃഷ്‌ടിക്കുകയോ ലയിപ്പിക്കാതിരിക്കുകയോ ചെയ്‌താൽ 0{40}.

7. ഒരു ഇടം.

8. "dst" എന്നതിനുള്ള sha1; 0{40} സൃഷ്‌ടിക്കുകയാണെങ്കിൽ, ലയിപ്പിക്കാത്തത് അല്ലെങ്കിൽ "വർക്ക് ട്രീയിലേക്ക് നോക്കുക".

9. ഒരു ഇടം.

10. സ്റ്റാറ്റസ്, തുടർന്ന് ഓപ്ഷണൽ "സ്കോർ" നമ്പർ.

11. ഒരു ടാബ് അല്ലെങ്കിൽ ഒരു NUL എപ്പോൾ -z ഓപ്ഷൻ ഉപയോഗിക്കുന്നു.

12. "src" എന്നതിനുള്ള പാത

13. ഒരു ടാബ് അല്ലെങ്കിൽ ഒരു NUL എപ്പോൾ -z ഓപ്ഷൻ ഉപയോഗിക്കുന്നു; C അല്ലെങ്കിൽ R ന് മാത്രം നിലവിലുണ്ട്.

14. "dst" എന്നതിനുള്ള പാത; C അല്ലെങ്കിൽ R ന് മാത്രം നിലവിലുണ്ട്.

15. ഒരു LF അല്ലെങ്കിൽ NUL എപ്പോൾ -z റെക്കോർഡ് അവസാനിപ്പിക്കാൻ ഓപ്ഷൻ ഉപയോഗിക്കുന്നു.

സാധ്യമായ സ്റ്റാറ്റസ് അക്ഷരങ്ങൾ ഇവയാണ്:

· എ: ഒരു ഫയൽ കൂട്ടിച്ചേർക്കൽ

· സി: ഒരു ഫയലിന്റെ പുതിയതിലേക്ക് പകർത്തുക

· ഡി: ഒരു ഫയൽ ഇല്ലാതാക്കൽ

· എം: ഒരു ഫയലിന്റെ ഉള്ളടക്കം അല്ലെങ്കിൽ മോഡ് പരിഷ്ക്കരണം

· R: ഒരു ഫയലിന്റെ പുനർനാമകരണം

· ടി: ഫയലിന്റെ തരത്തിൽ മാറ്റം

· യു: ഫയൽ ലയിപ്പിച്ചിട്ടില്ല (അത് പ്രതിജ്ഞാബദ്ധമാക്കുന്നതിന് മുമ്പ് നിങ്ങൾ ലയനം പൂർത്തിയാക്കണം)

X: "അജ്ഞാത" മാറ്റത്തിന്റെ തരം (മിക്കവാറും ഒരു ബഗ്, ദയവായി അത് റിപ്പോർട്ട് ചെയ്യുക)

സ്റ്റാറ്റസ് അക്ഷരങ്ങൾ C, R എന്നിവയ്ക്ക് ശേഷം എല്ലായ്പ്പോഴും ഒരു സ്കോർ ഉണ്ടാകും (ശതമാനം സൂചിപ്പിക്കുന്നത്
നീക്കം അല്ലെങ്കിൽ പകർപ്പിന്റെ ഉറവിടവും ലക്ഷ്യവും തമ്മിലുള്ള സാമ്യം). സ്റ്റാറ്റസ് ലെറ്റർ എം ആയിരിക്കാം
ഫയൽ റീറൈറ്റിംഗിനായി ഒരു സ്കോർ (അസമത്വത്തിന്റെ ശതമാനം സൂചിപ്പിക്കുന്നു).

ഫയൽസിസ്റ്റത്തിൽ ഒരു ഫയൽ പുതിയതും അത് സമന്വയിപ്പിക്കാത്തതും ആണെങ്കിൽ എല്ലാ 1 കളും ആയി കാണിക്കുന്നു
സൂചിക.

ഉദാഹരണം:

:100644 100644 5be4a4...... 000000...... M file.c

-z ഓപ്ഷൻ ഉപയോഗിക്കാത്തപ്പോൾ, TAB, LF, പാത്ത് നെയിമുകളിലെ ബാക്ക്സ്ലാഷ് പ്രതീകങ്ങൾ എന്നിവ പ്രതിനിധീകരിക്കുന്നു
യഥാക്രമം \t, \n, \\ എന്നിങ്ങനെ.

ഡിഐഎഫ്എഫ് ഫോർമാറ്റ് വേണ്ടി ലയിപ്പിക്കുന്നു

"git-diff-tree", "git-diff-files", "git-diff --raw" എന്നിവ എടുക്കാം -c or --cc ഓപ്ഷൻ
ലയന കമ്മിറ്റുകൾക്കും ഡിഫ് ഔട്ട്പുട്ട് സൃഷ്ടിക്കുക. വിവരിച്ച ഫോർമാറ്റിൽ നിന്ന് ഔട്ട്പുട്ട് വ്യത്യസ്തമാണ്
ഇനിപ്പറയുന്ന രീതിയിൽ മുകളിൽ:

1. ഓരോ രക്ഷിതാവിനും ഒരു കോളൻ ഉണ്ട്

2. കൂടുതൽ "src" മോഡുകളും "src" sha1 ഉം ഉണ്ട്

3. സ്റ്റാറ്റസ് എന്നത് ഓരോ രക്ഷിതാവിന്റെയും സ്റ്റാറ്റസ് പ്രതീകങ്ങളാണ്

4. ഓപ്ഷണൽ "സ്കോർ" നമ്പർ ഇല്ല

5. ഒറ്റ പാത, "dst" ന് മാത്രം

ഉദാഹരണം:

::100644 100644 100644 fabadb8... cc95eb0... 4866510... MM description.c

അതല്ല കൂടിച്ചേർന്നു ഡിഫ്എഫ് എല്ലാ മാതാപിതാക്കളിൽ നിന്നും പരിഷ്കരിച്ച ഫയലുകൾ മാത്രം ലിസ്റ്റ് ചെയ്യുന്നു.

ജനറേറ്റിംഗ് പാച്ചുകൾ ഉപയോഗിച്ച് -P

"git-diff-index", "git-diff-tree", അല്ലെങ്കിൽ "git-diff-files" എന്നിവ ഒരു ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കുമ്പോൾ -p ഓപ്ഷൻ, "ജിറ്റ്
വ്യത്യാസം" ഇല്ലാതെ --റോ ഓപ്ഷൻ, അല്ലെങ്കിൽ "-p" ഓപ്‌ഷനുള്ള "git log", അവ നിർമ്മിക്കുന്നില്ല
മുകളിൽ വിവരിച്ച ഔട്ട്പുട്ട്; പകരം അവർ ഒരു പാച്ച് ഫയൽ നിർമ്മിക്കുന്നു. നിങ്ങൾക്ക് സൃഷ്ടി ഇഷ്ടാനുസൃതമാക്കാം
GIT_EXTERNAL_DIFF, GIT_DIFF_OPTS എൻവയോൺമെന്റ് വേരിയബിളുകൾ വഴിയുള്ള അത്തരം പാച്ചുകൾ.

-p ഓപ്ഷൻ ഉത്പാദിപ്പിക്കുന്നത് പരമ്പരാഗത ഡിഫ് ഫോർമാറ്റിൽ നിന്ന് അല്പം വ്യത്യസ്തമാണ്:

1. ഇതിന് മുമ്പായി ഇതുപോലെ കാണപ്പെടുന്ന "ജിറ്റ് ഡിഫ്" തലക്കെട്ട്:

വ്യത്യാസം --git a/file1 b/file2

പുനർനാമകരണം/പകർപ്പ് ഉൾപ്പെട്ടിട്ടില്ലെങ്കിൽ, a/, b/ ഫയൽനാമങ്ങൾ ഒന്നുതന്നെയാണ്. പ്രത്യേകിച്ച്, പോലും
ഒരു സൃഷ്ടിക്ക് അല്ലെങ്കിൽ ഒരു ഇല്ലാതാക്കൽ, /dev/null ആണ് അല്ല a/ അല്ലെങ്കിൽ b/ എന്നതിന് പകരം ഉപയോഗിക്കുന്നു
ഫയൽനാമങ്ങൾ.

പുനർനാമകരണം/പകർപ്പ് ഉൾപ്പെടുമ്പോൾ, ഫയൽ1, ഫയൽ2 എന്നിവ സോഴ്സ് ഫയലിന്റെ പേര് കാണിക്കുന്നു
യഥാക്രമം പേരുമാറ്റുക/പകർപ്പ്, പുനർനാമകരണം/പകർപ്പ് നിർമ്മിക്കുന്ന ഫയലിന്റെ പേര്.

2. അതിന് ശേഷം ഒന്നോ അതിലധികമോ വിപുലീകൃത തലക്കെട്ടുകൾ ഉണ്ട്:

പഴയ മോഡ്
പുതിയ മോഡ്
ഇല്ലാതാക്കിയ ഫയൽ മോഡ്
പുതിയ ഫയൽ മോഡ്
നിന്ന് പകർത്തുക
പകർത്തുക
എന്നതിൽ നിന്ന് പുനർനാമകരണം ചെയ്യുക
എന്ന് പുനർനാമകരണം ചെയ്യുക
സമാനത സൂചിക
അസമത്വ സൂചിക
സൂചിക ..

ഫയൽ തരവും ഫയലും ഉൾപ്പെടെ 6-അക്ക ഒക്ടൽ നമ്പറുകളായി ഫയൽ മോഡുകൾ പ്രിന്റ് ചെയ്യുന്നു
അനുമതി ബിറ്റുകൾ.

വിപുലീകൃത തലക്കെട്ടുകളിലെ പാത നാമങ്ങളിൽ a/, b/ പ്രിഫിക്സുകൾ ഉൾപ്പെടുന്നില്ല.

സമാനത സൂചിക എന്നത് മാറ്റമില്ലാത്ത വരികളുടെ ശതമാനവും അസമത്വ സൂചികയുമാണ്
മാറിയ വരികളുടെ ശതമാനമാണ്. ഇത് ഒരു വൃത്താകൃതിയിലുള്ള പൂർണ്ണസംഖ്യയാണ്, തുടർന്ന് a
ശതമാനം അടയാളം. 100% സാമ്യത സൂചിക മൂല്യം രണ്ട് തുല്യ ഫയലുകൾക്കായി നീക്കിവച്ചിരിക്കുന്നു,
100% പൊരുത്തക്കേട് അർത്ഥമാക്കുന്നത് പഴയ ഫയലിൽ നിന്നുള്ള ഒരു വരിയും പുതിയതാക്കിയില്ല എന്നാണ്
ഒന്ന്.

മാറ്റത്തിന് മുമ്പും ശേഷവും സൂചിക ലൈനിൽ SHA-1 ചെക്ക്സം ഉൾപ്പെടുന്നു. ദി ആണ്
ഫയൽ മോഡ് മാറുന്നില്ലെങ്കിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്; അല്ലെങ്കിൽ, പ്രത്യേക വരികൾ പഴയതിനെ സൂചിപ്പിക്കുന്നു
പുതിയ മോഡും.

3. പാത്ത് നെയിമുകളിലെ TAB, LF, ഇരട്ട ഉദ്ധരണി, ബാക്ക്‌സ്ലാഷ് പ്രതീകങ്ങൾ എന്നിവ \t, \n,
യഥാക്രമം \", \\ എന്നിവ. അങ്ങനെയൊരു പകരം വയ്ക്കൽ ആവശ്യമുണ്ടെങ്കിൽ, മുഴുവൻ
പാതയുടെ പേര് ഇരട്ട ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.

4. ഔട്ട്‌പുട്ടിലെ എല്ലാ ഫയൽ1 ഫയലുകളും പ്രതിബദ്ധതയ്‌ക്ക് മുമ്പുള്ള ഫയലുകളെയും എല്ലാ ഫയൽ2യെയും സൂചിപ്പിക്കുന്നു
ഫയലുകൾ കമ്മിറ്റിന് ശേഷമുള്ള ഫയലുകളെയാണ് സൂചിപ്പിക്കുന്നത്. ഓരോ മാറ്റവും ഓരോന്നിനും ബാധകമാക്കുന്നത് തെറ്റാണ്
തുടർച്ചയായി ഫയൽ ചെയ്യുക. ഉദാഹരണത്തിന്, ഈ പാച്ച് a, b എന്നിവ സ്വാപ്പ് ചെയ്യും:

വ്യത്യാസം --git a/ab/b
a എന്നതിൽ നിന്ന് പുനർനാമകരണം ചെയ്യുക
ബി എന്ന് പുനർനാമകരണം ചെയ്യുക
വ്യത്യാസം --git a/bb/a
b എന്നതിൽ നിന്ന് പുനർനാമകരണം ചെയ്യുക
a എന്നാക്കി മാറ്റുക

സംയോജിപ്പിച്ചു ഡിഐഎഫ്എഫ് ഫോർമാറ്റ്

ഏത് ഡിഫ് ജനറേറ്റിംഗ് കമാൻഡിനും -c അല്ലെങ്കിൽ --cc ഓപ്ഷൻ എടുത്ത് a നിർമ്മിക്കാം കൂടിച്ചേർന്നു ഡിഫ്എഫ് എപ്പോൾ
ഒരു ലയനം കാണിക്കുന്നു. ലയനം കാണിക്കുമ്പോൾ ഇതാണ് സ്ഥിരസ്ഥിതി ഫോർമാറ്റ് git-diff(1) അല്ലെങ്കിൽ git-
കാണിക്കുക(1). നിർബന്ധിക്കാൻ ഈ കമാൻഡുകളിലേതെങ്കിലും നിങ്ങൾക്ക് -m ഓപ്ഷൻ നൽകാമെന്നതും ശ്രദ്ധിക്കുക
ഒരു ലയനത്തിന്റെ വ്യക്തിഗത മാതാപിതാക്കളുമായുള്ള വ്യത്യാസങ്ങളുടെ തലമുറ.

A കൂടിച്ചേർന്നു ഡിഫ്എഫ് ഫോർമാറ്റ് ഇതുപോലെ കാണപ്പെടുന്നു:

diff --combined description.c
സൂചിക fabadb8,cc95eb0..4866510
--- a/describe.c
+++ b/describe.c
@@@ -98,20 -98,12 +98,20 @@@
മടങ്ങുക (a_date > b_date) ? -1 : (a_date == b_date) ? 0 : 1;
}

- സ്റ്റാറ്റിക് ശൂന്യ വിവരണം (char *arg)
-സ്റ്റാറ്റിക് ശൂന്യ വിവരണം (സ്ട്രക്റ്റ് കമ്മിറ്റ് *cmit, int last_one)
++ സ്റ്റാറ്റിക് ശൂന്യ വിവരണം (char *arg, int last_one)
{
+ ഒപ്പിടാത്ത ചാർ ഷാ1[20];
+ struct കമ്മിറ്റ് *cmit;
struct commit_list *ലിസ്റ്റ്;
സ്റ്റാറ്റിക് ഇനീഷ്യസ് = 0;
struct commit_name *n;

+ എങ്കിൽ (get_sha1(arg, sha1) < 0)
+ ഉപയോഗം (ഉപയോഗം വിവരിക്കുക);
+ cmit = lookup_commit_reference(sha1);
+ എങ്കിൽ (!cmit)
+ ഉപയോഗം (ഉപയോഗം വിവരിക്കുക);
+
എങ്കിൽ (!തുടങ്ങി) {
ആരംഭിച്ചത് = 1;
for_each_ref(get_name);

1. ഇതിന് മുമ്പായി "ജിറ്റ് ഡിഫ്" എന്ന തലക്കെട്ട് ഇതുപോലെ കാണപ്പെടുന്നു (എപ്പോൾ -c ഓപ്ഷൻ ആണ്
ഉപയോഗിച്ചു):

diff --combined ഫയൽ

അല്ലെങ്കിൽ ഇതുപോലെ (എപ്പോൾ --cc ഓപ്ഷൻ ഉപയോഗിക്കുന്നു):

diff --cc ഫയൽ

2. അതിന് ശേഷം ഒന്നോ അതിലധികമോ വിപുലീകൃത തലക്കെട്ടുകൾ (ഈ ഉദാഹരണം ഒരു ലയനം കാണിക്കുന്നു
രണ്ട് മാതാപിതാക്കൾ):

സൂചിക , ..
മോഡ് , ..
പുതിയ ഫയൽ മോഡ്
ഇല്ലാതാക്കിയ ഫയൽ മോഡ് ,

മോഡ് , .. വരിയിൽ ഒരെണ്ണമെങ്കിലും മാത്രമേ ദൃശ്യമാകൂ ആണ്
ബാക്കിയുള്ളതിൽ നിന്ന് വ്യത്യസ്തമാണ്. കണ്ടെത്തിയ ഉള്ളടക്കങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങളുള്ള വിപുലീകരിച്ച തലക്കെട്ടുകൾ
ചലനം (പുനർനാമകരണങ്ങളും പകർത്തൽ കണ്ടെത്തലും) രണ്ടിന്റെ വ്യത്യാസത്തിൽ പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു
സംയോജിത ഡിഫ് ഫോർമാറ്റിൽ ഉപയോഗിക്കുന്നില്ല.

3. അതിനു ശേഷം ഫയലിൽ നിന്ന് / ഫയലിലേക്ക് രണ്ട്-വരി തലക്കെട്ട്

--- ഒരു ഫയല്
+++ ബി/ഫയൽ

പരമ്പരാഗതമായ രണ്ട്-വരി തലക്കെട്ടിന് സമാനമാണ് ഏകീകൃത ഡിഫ് ഫോർമാറ്റ്, /dev/null ഉപയോഗിക്കുന്നു
സിഗ്നൽ സൃഷ്ടിച്ചതോ ഇല്ലാതാക്കിയതോ ആയ ഫയലുകൾ.

4. ചങ്ക് ഹെഡർ ഫോർമാറ്റ് ആളുകൾക്ക് ആകസ്മികമായി ഭക്ഷണം നൽകുന്നത് തടയാൻ പരിഷ്‌ക്കരിച്ചിരിക്കുന്നു
പാച്ച് -p1. ലയന കമ്മിറ്റ് മാറ്റങ്ങളുടെ അവലോകനത്തിനായി സംയോജിത ഡിഫ് ഫോർമാറ്റ് സൃഷ്ടിച്ചു, കൂടാതെ
അപേക്ഷിക്കാൻ ഉദ്ദേശിച്ചിരുന്നില്ല. വിപുലീകരിച്ച മാറ്റത്തിന് സമാനമാണ് മാറ്റം സൂചിക
തലക്കെട്ട്:

@@@ @@@

സംയോജിത വ്യത്യാസത്തിനായി ചങ്ക് ഹെഡറിൽ (മാതാപിതാക്കളുടെ എണ്ണം + 1) @ പ്രതീകങ്ങളുണ്ട്
ഫോർമാറ്റ്.

പരമ്പരാഗതത്തിൽ നിന്ന് വ്യത്യസ്തമായി ഏകീകൃത ഡിഫ് ഫോർമാറ്റ്, ഇത് രണ്ട് ഫയലുകൾ എ, ബി എന്നിവ കാണിക്കുന്നു
കോളത്തിൽ - (മൈനസ് — A-ൽ ദൃശ്യമാണെങ്കിലും B-യിൽ നീക്കംചെയ്തു), + (പ്ലസ് — A-യിൽ കാണുന്നില്ല
ബി) അല്ലെങ്കിൽ "" (സ്പേസ് — മാറ്റമില്ലാത്തത്) പ്രിഫിക്സിലേക്ക് ചേർത്തു, ഈ ഫോർമാറ്റ് രണ്ടോ അതിലധികമോ ഫയലുകൾ താരതമ്യം ചെയ്യുന്നു
file1, file2,... ഒരു ഫയൽ X ഉപയോഗിച്ച്, കൂടാതെ X ഓരോ fileN-ൽ നിന്നും എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു എന്ന് കാണിക്കുന്നു. ഒരു കോളം
എക്‌സിന്റെ ലൈൻ എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു എന്നറിയാൻ ഓരോ ഫയലിനും N ഔട്ട്‌പുട്ട് ലൈനിലേക്ക് മുൻകൈയെടുത്തു
അതു.

A - നിര N എന്ന അക്ഷരം അർത്ഥമാക്കുന്നത് ലൈൻ fileN-ൽ ദൃശ്യമാണെങ്കിലും അത് ദൃശ്യമാകില്ല എന്നാണ്
ഫലത്തിൽ. N നിരയിലെ A + പ്രതീകം അർത്ഥമാക്കുന്നത് ഫലത്തിൽ ലൈൻ ദൃശ്യമാകുന്നു എന്നാണ്,
and fileN ന് ആ വരി ഇല്ല (മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, എന്ന പോയിന്റിൽ നിന്നാണ് ലൈൻ ചേർത്തത്
ആ മാതാപിതാക്കളുടെ വീക്ഷണം).

മുകളിലുള്ള ഉദാഹരണ ഔട്ട്‌പുട്ടിൽ, രണ്ട് ഫയലുകളിൽ നിന്നും ഫംഗ്‌ഷൻ സിഗ്നേച്ചർ മാറ്റി (അതിനാൽ രണ്ട്
- ഫയൽ1, ഫയൽ2 എന്നിവയിൽ നിന്നും നീക്കം ചെയ്യലുകൾ, കൂടാതെ ++ എന്നതിനർത്ഥം ചേർത്ത ഒരു വരി അല്ല
ഫയൽ1 അല്ലെങ്കിൽ ഫയൽ2 എന്നിവയിൽ ദൃശ്യമാകും. കൂടാതെ മറ്റ് എട്ട് ലൈനുകളും ഫയൽ1-ൽ നിന്ന് സമാനമാണ്, പക്ഷേ ചെയ്യുക
ഫയൽ2-ൽ ദൃശ്യമാകില്ല (അതിനാൽ + എന്ന പ്രിഫിക്‌സ്).

git diff-tree -c കാണിക്കുമ്പോൾ, അത് ഒരു ലയനത്തിന്റെ മാതാപിതാക്കളെ ലയനവുമായി താരതമ്യം ചെയ്യുന്നു
ഫലം (അതായത് file1..fileN മാതാപിതാക്കളാണ്). git diff-files -c കാണിക്കുമ്പോൾ, അത് താരതമ്യം ചെയ്യുന്നു
പരിഹരിക്കപ്പെടാത്ത രണ്ട് മാതാപിതാക്കളും പ്രവർത്തിക്കുന്ന ട്രീ ഫയലുമായി ലയിപ്പിക്കുന്നു (അതായത് ഫയൽ1 സ്റ്റേജ് 2 ആണ്
"ഞങ്ങളുടെ പതിപ്പ്", ഫയൽ2 സ്റ്റേജ് 3 അല്ലെങ്കിൽ "അവരുടെ പതിപ്പ്" ആണ്).

മറ്റുള്ളവ ഡിഐഎഫ്എഫ് ഫോർമാറ്റുകൾ

--സമ്മറി ഓപ്‌ഷൻ പുതിയതായി ചേർത്തതും ഇല്ലാതാക്കിയതും പേരുമാറ്റിയതും പകർത്തിയതുമായ ഫയലുകളെ വിവരിക്കുന്നു. --സ്റ്റാറ്റ്
ഓപ്ഷൻ ചേർക്കുന്നു ഡിഫ്സ്റ്റാറ്റ്(1) ഔട്ട്പുട്ടിലേക്കുള്ള ഗ്രാഫ്. ഈ ഓപ്ഷനുകൾ മറ്റുള്ളവയുമായി സംയോജിപ്പിക്കാം
-p പോലുള്ള ഓപ്ഷനുകൾ, മനുഷ്യ ഉപഭോഗത്തിന് വേണ്ടിയുള്ളവയാണ്.

ഒരു പുനർനാമകരണമോ പകർപ്പോ ഉൾപ്പെടുന്ന ഒരു മാറ്റം കാണിക്കുമ്പോൾ, --stat ഔട്ട്പുട്ട് ഫോർമാറ്റ് ചെയ്യുന്നു
പാത്ത് നെയിമുകളുടെ പൊതുവായ പ്രിഫിക്സും പ്രത്യയവും സംയോജിപ്പിച്ച് ഒതുക്കമുള്ള പാത്ത് നാമങ്ങൾ. ഉദാഹരണത്തിന്, എ
386 വരികൾ പരിഷ്കരിക്കുമ്പോൾ arch/i86/Makefile-നെ arch/x4/Makefile-ലേക്ക് മാറ്റുന്ന മാറ്റം
ഇതുപോലെ കാണിച്ചിരിക്കുന്നു:

arch/{i386 => x86}/Makefile | 4 +--

--numstat ഓപ്ഷൻ നൽകുന്നു ഡിഫ്സ്റ്റാറ്റ്(1) വിവരങ്ങൾ എന്നാൽ എളുപ്പമുള്ള മെഷീനായി രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്
ഉപഭോഗം. --numstat ഔട്ട്പുട്ടിലെ ഒരു എൻട്രി ഇതുപോലെ കാണപ്പെടുന്നു:

1 2 വായിക്കുക
3 1 കമാനം/{i386 => x86}/Makefile

അതായത്, ഇടത്തുനിന്ന് വലത്തോട്ട്:

1. ചേർത്ത വരികളുടെ എണ്ണം;

2. ഒരു ടാബ്;

3. ഇല്ലാതാക്കിയ വരികളുടെ എണ്ണം;

4. ഒരു ടാബ്;

5. പാതയുടെ പേര് (ഒരുപക്ഷേ, വിവരങ്ങളുടെ പുനർനാമകരണം/പകർപ്പ് എന്നിവ ഉപയോഗിച്ച്);

6. ഒരു പുതിയ ലൈൻ.

-z ഔട്ട്പുട്ട് ഓപ്ഷൻ പ്രാബല്യത്തിൽ വരുമ്പോൾ, ഔട്ട്പുട്ട് ഈ രീതിയിൽ ഫോർമാറ്റ് ചെയ്യപ്പെടുന്നു:

1 2 README NUL
3 1 NUL arch/i386/Makefile NUL ആർച്ച്/x86/Makefile NUL

അതാണ്:

1. ചേർത്ത വരികളുടെ എണ്ണം;

2. ഒരു ടാബ്;

3. ഇല്ലാതാക്കിയ വരികളുടെ എണ്ണം;

4. ഒരു ടാബ്;

5. ഒരു NUL (പേരുമാറ്റി / പകർത്തിയാൽ മാത്രമേ നിലനിൽക്കൂ);

6. മുൻചിത്രത്തിലെ പാതനാമം;

7. ഒരു NUL (പേരുമാറ്റി / പകർത്തിയാൽ മാത്രമേ നിലനിൽക്കൂ);

8. പോസ്‌റ്റിമേജിലെ പാതയുടെ പേര് (പേരുമാറ്റി/പകർത്തുകയാണെങ്കിൽ മാത്രമേ നിലനിൽക്കൂ);

9. ഒരു NUL.

പുനർനാമകരണം ചെയ്ത കേസിൽ പ്രീമേജ് പാതയ്ക്ക് മുമ്പുള്ള അധിക NUL എന്നത് വായിക്കുന്ന സ്ക്രിപ്റ്റുകൾ അനുവദിക്കുക എന്നതാണ്
നിലവിൽ വായിക്കുന്ന റെക്കോർഡ് ഒരു ഏകപാത റെക്കോർഡാണോ അതോ പേരുമാറ്റുക/പകർപ്പാണോ എന്ന് പറയാൻ ഔട്ട്‌പുട്ട്
മുൻകൂട്ടി വായിക്കാതെ റെക്കോർഡ് ചെയ്യുക. ചേർത്തതും ഇല്ലാതാക്കിയതുമായ വരികൾ വായിച്ചതിനുശേഷം, NUL വരെ വായിക്കുക
പാതയുടെ പേര് നൽകും, പക്ഷേ അത് NUL ആണെങ്കിൽ, റെക്കോർഡ് രണ്ട് പാതകൾ കാണിക്കും.

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

ഇൻഡെക്സ് ഫയലിനെ പൂർണ്ണമായും വിശ്വസിക്കണോ എന്ന് നിങ്ങൾക്ക് തിരഞ്ഞെടുക്കാം (ഉപയോഗിച്ച് --കാഷ് ചെയ്തു പതാക)
അല്ലെങ്കിൽ സ്റ്റാറ്റ് അവസ്ഥയുമായി പൊരുത്തപ്പെടാത്ത ഏതെങ്കിലും ഫയലുകൾ കാണിക്കാൻ ഡിഫ് ലോജിക്ക് ആവശ്യപ്പെടുക
"താൽക്കാലികമായി മാറ്റി". ഈ രണ്ട് പ്രവർത്തനങ്ങളും വളരെ ഉപയോഗപ്രദമാണ്.

കാഷെ ചെയ്തു MODE

If --കാഷ് ചെയ്തു വ്യക്തമാക്കിയിരിക്കുന്നു, ഇത് ചോദിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു:

HEAD ഉം നിലവിലെ സൂചികയും തമ്മിലുള്ള വ്യത്യാസങ്ങൾ എന്നെ കാണിക്കൂ
ഉള്ളടക്കം ('ജിറ്റ് റൈറ്റ്-ട്രീ' ഉപയോഗിച്ച് ഞാൻ എഴുതുന്നവ)

ഉദാഹരണത്തിന്, നിങ്ങളുടെ വർക്കിംഗ് ഡയറക്‌ടറിയിൽ നിങ്ങൾ പ്രവർത്തിച്ചു, ചില ഫയലുകൾ അപ്‌ഡേറ്റ് ചെയ്‌തുവെന്ന് പറയാം
സൂചികയിലുണ്ട്, പ്രതിബദ്ധതയ്ക്ക് തയ്യാറാണ്. നിങ്ങൾ കൃത്യമായി കാണണം എന്ത് നിങ്ങൾ പോകുന്നു
ഒരു പുതിയ ട്രീ ഒബ്‌ജക്‌റ്റ് എഴുതുകയും അത് അങ്ങനെ താരതമ്യം ചെയ്യുകയും ചെയ്യാതെ, അത് ചെയ്യാൻ
നിങ്ങൾ ചെയ്യുക

git diff-index --കാഷെഡ് ഹെഡ്

ഉദാഹരണം: ഞാൻ കമ്മിറ്റ്.സി എന്ന പേര് git-commit.c എന്ന് പുനർനാമകരണം ചെയ്തു, ഞാൻ ഒരു അപ്‌ഡേറ്റ്-ഇൻഡക്സ് ചെയ്തുവെന്ന് പറയാം.
സൂചിക ഫയലിൽ അത് ഫലപ്രദമാക്കാൻ. git diff-files ഒന്നും കാണിക്കില്ല,
ഇൻഡെക്സ് ഫയൽ എന്റെ പ്രവർത്തന ഡയറക്ടറിയുമായി പൊരുത്തപ്പെടുന്നതിനാൽ. എന്നാൽ ഒരു ചെയ്യുന്നത് ജിറ്റിനെ വ്യത്യാസ സൂചിക ചെയ്യുന്നു:

torvalds@ppc970:~/git> git diff-index --കാഷെഡ് ഹെഡ്
-100644 blob 4161aecc6700a2eb579e842af0b7f22b98443f74 commit.c
+100644 blob 4161aecc6700a2eb579e842af0b7f22b98443f74 git-commit.c

മുകളിലുള്ളത് ഒരു പേരുമാറ്റമാണെന്ന് നിങ്ങൾക്ക് എളുപ്പത്തിൽ കാണാൻ കഴിയും.

വാസ്തവത്തിൽ, git diff-index --cached വേണം എല്ലായ്‌പ്പോഴും ഒരു യഥാർത്ഥത്തിൽ ചെയ്യുന്നതിനു തുല്യമായിരിക്കണം
ജിറ്റിനെ എഴുത്ത്-മരം അത് താരതമ്യം ചെയ്യുന്നു. ഇത് ഒഴികെ നിങ്ങൾ ഉള്ള സാഹചര്യത്തിൽ ഇത് വളരെ മനോഹരമാണ്
നിങ്ങൾ എവിടെയാണെന്ന് പരിശോധിക്കാൻ ആഗ്രഹിക്കുന്നു.

അതിനാൽ നിങ്ങൾ സ്വയം ചോദിക്കുമ്പോൾ ഒരു git diff-index --cached ചെയ്യുന്നത് അടിസ്ഥാനപരമായി വളരെ ഉപയോഗപ്രദമാണ്
"പ്രതിബദ്ധതയുള്ളതായി ഞാൻ ഇതിനകം അടയാളപ്പെടുത്തിയത് എന്താണ്, മുമ്പത്തേതിൽ നിന്ന് എന്താണ് വ്യത്യാസം
വൃക്ഷം".

കാഷ് ചെയ്യാത്തത് MODE

"നോൺ-കാഷെഡ്" മോഡ് മറ്റൊരു സമീപനം സ്വീകരിക്കുന്നു, അത് കൂടുതൽ ഉപയോഗപ്രദമാകാൻ സാധ്യതയുണ്ട്
രണ്ടും അത് ചെയ്യുന്നതിനെ അനുകരിക്കാൻ കഴിയില്ല ജിറ്റിനെ എഴുത്ത്-മരം + ജിറ്റിനെ വ്യത്യാസം-മരം. അങ്ങനെ
അതാണ് ഡിഫോൾട്ട് മോഡ്. കാഷെ ചെയ്യാത്ത പതിപ്പ് ചോദ്യം ചോദിക്കുന്നു:

HEAD ഉം നിലവിൽ പരിശോധിച്ചതും തമ്മിലുള്ള വ്യത്യാസങ്ങൾ എന്നെ കാണിക്കൂ
ട്രീ - ഇൻഡക്സ് ഉള്ളടക്കങ്ങൾ _and_ ഫയലുകൾ കാലികമല്ല

ഇത് വളരെ ഉപയോഗപ്രദമായ ഒരു ചോദ്യമാണ്, കാരണം അത് നിങ്ങളോട് എന്താണ് പറയുന്നതെന്ന് could പ്രതിജ്ഞാബദ്ധത.
വീണ്ടും, ഔട്ട്പുട്ട് പൊരുത്തപ്പെടുന്നു ജിറ്റിനെ വ്യത്യാസം-മരം -r ഒരു ടീയിലേക്ക് ഔട്ട്പുട്ട്, പക്ഷേ ഒരു ട്വിസ്റ്റ്.

ചില ഫയൽ സൂചികയുമായി പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, ഞങ്ങൾക്ക് ഒരു ബാക്കിംഗ് സ്റ്റോർ ഇല്ല എന്നതാണ് ട്വിസ്റ്റ്
അതിനുള്ള കാര്യം, അത് കാണിക്കാൻ ഞങ്ങൾ മാജിക് "ഓൾ-സീറോ" sha1 ഉപയോഗിക്കുന്നു. അതിനാൽ നിങ്ങൾ എന്ന് പറയാം
kernel/sched.c എഡിറ്റ് ചെയ്തിട്ടുണ്ട്, എന്നാൽ യഥാർത്ഥത്തിൽ ഒരു ചെയ്തിട്ടില്ല ജിറ്റിനെ അപ്ഡേറ്റ്-ഇൻഡക്സ് അതിൽ ഇതുവരെ -
പുതിയ സംസ്ഥാനവുമായി ബന്ധപ്പെട്ട "വസ്തു" ഒന്നുമില്ല, നിങ്ങൾക്ക് ലഭിക്കുന്നത്:

torvalds@ppc970:~/v2.6/linux> git diff-index --abbrev HEAD
:100644 100664 7476bb... 000000... kernel/sched.c

അതായത്, ട്രീ മാറിയെന്നും kernel/sched.c കാലികമല്ലെന്നും ഇത് കാണിക്കുന്നു
കൂടാതെ പുതിയ കാര്യങ്ങൾ അടങ്ങിയിരിക്കാം. എല്ലാ-പൂജ്യം sha1 അർത്ഥമാക്കുന്നത് യഥാർത്ഥ വ്യത്യാസം ലഭിക്കാൻ, നിങ്ങൾ ചെയ്യേണ്ടത് എന്നാണ്
ഒബ്‌ജക്‌റ്റ് ടു ഒബ്‌ജക്‌റ്റ് ചെയ്യുന്നതിനുപകരം പ്രവർത്തിക്കുന്ന ഡയറക്‌ടറിയിലെ ഒബ്‌ജക്‌റ്റിലേക്ക് നേരിട്ട് നോക്കുക
വ്യത്യാസം.

കുറിപ്പ്
ഈ തരത്തിലുള്ള മറ്റ് കമാൻഡുകൾ പോലെ, ജിറ്റിനെ വ്യത്യാസ സൂചിക യഥാർത്ഥത്തിൽ നോക്കുന്നില്ല
ഫയലിന്റെ എല്ലാ ഉള്ളടക്കവും. അതുകൊണ്ടായിരിക്കാം kernel/sched.c യഥാർത്ഥത്തിൽ മാറിയിട്ടില്ല, അത്
നീ അതിൽ തൊട്ടു എന്ന് മാത്രം. ഏത് സാഹചര്യത്തിലും, ഇത് നിങ്ങൾക്ക് ആവശ്യമുള്ള ഒരു കുറിപ്പാണ് ജിറ്റിനെ
അപ്ഡേറ്റ്-ഇൻഡക്സ് സൂചിക സമന്വയിപ്പിക്കുന്നതിന്.

കുറിപ്പ്
"അപ്‌ഡേറ്റ് ചെയ്‌തിരിക്കുന്നു", "ഇപ്പോഴും വൃത്തികെട്ടതാണ്" എന്നിങ്ങനെയുള്ള ഫയലുകളുടെ ഒരു മിശ്രിതം നിങ്ങൾക്ക് കാണിക്കാനാകും
പ്രവർത്തിക്കുന്ന ഡയറക്‌ടറി" ഒരുമിച്ച്. ഏത് ഫയൽ ഏത് അവസ്ഥയിലാണെന്ന് നിങ്ങൾക്ക് എപ്പോഴും പറയാനാകും,
"അപ്‌ഡേറ്റ് ചെയ്‌തിരിക്കുന്നു" എന്നതിനാൽ സാധുവായ ഒരു sha1 കാണിക്കുന്നു, കൂടാതെ "ഇതുമായി സമന്വയിപ്പിച്ചിട്ടില്ല
സൂചിക" എന്നതിന് എല്ലായ്‌പ്പോഴും സ്പെഷ്യൽ ഓൾ-സീറോ sha1 ഉണ്ടായിരിക്കും.

GIT

ഭാഗം ജിറ്റിനെ(1) സ്യൂട്ട്

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