git-read-tree - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

git-read-tree - ട്രീ വിവരങ്ങൾ സൂചികയിലേക്ക് വായിക്കുന്നു

സിനോപ്സിസ്

ജിറ്റിനെ വായന-മരം [[-m [--നിസ്സാര] [--ആക്രമണാത്മക] | --റീസെറ്റ് | --പ്രിഫിക്സ്= ]
[-u [--exclude-per-directory= ] | -i]]
[--index-output= ] [--നോ-സ്പാർസ്-ചെക്കൗട്ട്]
(--ശൂന്യം | [ [ ]])

വിവരണം

നൽകിയ വൃക്ഷ വിവരം വായിക്കുന്നു സൂചികയിലേക്ക്, എന്നാൽ യഥാർത്ഥത്തിൽ ഇല്ല
അപ്ഡേറ്റ് ഏതെങ്കിലും ഫയലുകൾ അത് "കാഷെ ചെയ്യുന്നു". (കാണുക: git-checkout-index(1))

ഓപ്ഷണലായി, ഇതിന് ഒരു ട്രീയെ സൂചികയിലേക്ക് ലയിപ്പിക്കാനും ഫാസ്റ്റ് ഫോർവേഡ് (അതായത് 2-വേ) ലയനം നടത്താനും കഴിയും,
അല്ലെങ്കിൽ -m ഫ്ലാഗിനൊപ്പം 3-വേ ലയനം. -m ഉപയോഗിച്ച് ഉപയോഗിക്കുമ്പോൾ, -u ഫ്ലാഗ് അതിന് കാരണമാകുന്നു
ലയനത്തിന്റെ ഫലം ഉപയോഗിച്ച് വർക്ക് ട്രീയിലെ ഫയലുകൾ അപ്‌ഡേറ്റ് ചെയ്യുക.

നിസ്സാരമായ ലയനങ്ങൾ നടത്തുന്നത് ജിറ്റിനെ വായന-മരം തന്നെ. പരസ്പരവിരുദ്ധമായ പാതകൾ മാത്രമേ ഉള്ളൂ
എപ്പോൾ ലയിപ്പിക്കാത്ത അവസ്ഥ ജിറ്റിനെ വായന-മരം തിരികെ വരുത്തുന്നു.

ഓപ്ഷനുകൾ

-m
ഒരു വായന മാത്രമല്ല, ഒരു ലയനം നടത്തുക. നിങ്ങളുടെ ഇൻഡെക്സ് ഫയൽ ആണെങ്കിൽ കമാൻഡ് പ്രവർത്തിക്കാൻ വിസമ്മതിക്കും
ലയിപ്പിക്കാത്ത എൻട്രികൾ ഉണ്ട്, നിങ്ങൾ മുമ്പത്തെ ലയനം പൂർത്തിയാക്കിയിട്ടില്ലെന്ന് സൂചിപ്പിക്കുന്നു
ആരംഭിച്ചു.

--പുനഃസജ്ജമാക്കുക
-m പോലെ തന്നെ, ലയിപ്പിക്കാത്ത എൻട്രികൾ പരാജയപ്പെടുന്നതിനുപകരം നിരസിക്കപ്പെടുന്നു എന്നതൊഴിച്ചാൽ.

-u
വിജയകരമായ ഒരു ലയനത്തിനുശേഷം, വർക്ക് ട്രീയിലെ ഫയലുകൾ അതിന്റെ ഫലം ഉപയോഗിച്ച് അപ്‌ഡേറ്റ് ചെയ്യുക
ലയിപ്പിക്കുക.

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

-n, --ഡ്രൈ-റൺ
ഇൻഡെക്‌സോ ഫയലുകളോ അപ്‌ഡേറ്റ് ചെയ്യാതെ, കമാൻഡ് പിശക് സംഭവിക്കുമോയെന്ന് പരിശോധിക്കുക
യഥാർത്ഥത്തിൽ ജോലി ചെയ്യുന്ന മരം.

-v
ഫയലുകൾ പരിശോധിക്കുന്നതിന്റെ പുരോഗതി കാണിക്കുക.

--നിസ്സാരമായ
ത്രീ-വേ ലയനം നിയന്ത്രിക്കുക ജിറ്റിനെ വായന-മരം ഫയൽ-ലെവൽ ഇല്ലെങ്കിൽ മാത്രമേ സംഭവിക്കൂ
നിസ്സാരമായ കേസുകളുടെ ലയനം പരിഹരിച്ച് വൈരുദ്ധ്യമുണ്ടാക്കുന്നതിന് പകരം ലയിപ്പിക്കൽ ആവശ്യമാണ്
സൂചികയിൽ പരിഹരിക്കപ്പെടാത്ത ഫയലുകൾ.

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

· ഒരു വശം ഒരു പാത നീക്കം ചെയ്യുകയും മറുവശം പാതയിൽ മാറ്റം വരുത്താതെ വിടുകയും ചെയ്യുമ്പോൾ. ദി
ആ പാത നീക്കം ചെയ്യുക എന്നതാണ് പ്രമേയം.

· ഇരുവശവും ഒരു പാത നീക്കം ചെയ്യുമ്പോൾ. ആ പാത ഒഴിവാക്കാനാണ് തീരുമാനം.

· ഇരുവശവും ഒരേപോലെ ഒരു പാത ചേർക്കുമ്പോൾ. ആ പാത കൂട്ടിച്ചേർക്കാനാണ് പ്രമേയം.

--പ്രിഫിക്സ്= /
നിലവിലെ സൂചിക ഉള്ളടക്കങ്ങൾ സൂക്ഷിക്കുക, പേരിട്ടിരിക്കുന്ന ട്രീ-ഇഷിന്റെ ഉള്ളടക്കം വായിക്കുക
എന്ന ഡയറക്ടറി . ഇതിനകം എൻട്രികൾ തിരുത്തിയെഴുതാൻ കമാൻഡ് നിരസിക്കും
യഥാർത്ഥ സൂചിക ഫയലിൽ നിലവിലുണ്ടായിരുന്നു. എന്നത് ശ്രദ്ധിക്കുക / മൂല്യം a എന്നതിൽ അവസാനിക്കണം
വെട്ടിമുറിക്കുക.

--exclude-per-directory=
-u, -m ഓപ്ഷനുകൾ ഉപയോഗിച്ച് കമാൻഡ് പ്രവർത്തിപ്പിക്കുമ്പോൾ, ലയന ഫലം ആവശ്യമായി വന്നേക്കാം
നിലവിലെ ബ്രാഞ്ചിൽ ട്രാക്ക് ചെയ്യാത്ത പാതകൾ തിരുത്തിയെഴുതുക. കമാൻഡ് സാധാരണയായി
അത്തരമൊരു പാത നഷ്ടപ്പെടാതിരിക്കാൻ ലയനവുമായി മുന്നോട്ട് പോകാൻ വിസമ്മതിക്കുന്നു. എന്നിരുന്നാലും ഈ സുരക്ഷ
വാൽവ് ചിലപ്പോൾ തടസ്സമാകും. ഉദാഹരണത്തിന്, അത് പലപ്പോഴും മറ്റ് ബ്രാഞ്ച് സംഭവിക്കുന്നു
നിങ്ങളുടെ ബ്രാഞ്ചിൽ ജനറേറ്റ് ചെയ്ത ഫയലായിരുന്ന ഒരു ഫയലും സുരക്ഷാ വാൽവും ചേർത്തു
നിങ്ങൾ ഓടിച്ചതിന് ശേഷം ആ ശാഖയിലേക്ക് മാറാൻ ശ്രമിക്കുമ്പോൾ ട്രിഗറുകൾ ഉണ്ടാക്കുന്നു, എന്നാൽ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്
സൃഷ്ടിച്ച ഫയൽ നീക്കം ചെയ്യാൻ വൃത്തിയാക്കുക. ഈ ഓപ്‌ഷൻ വായിക്കാനുള്ള കമാൻഡിനോട് പറയുന്നു
ഓരോ ഡയറക്‌ടറിയും ഒഴിവാക്കുന്ന ഫയൽ (സാധാരണയായി .ജിറ്റിഗ്നോർ) കൂടാതെ അത്തരം ട്രാക്ക് ചെയ്യപ്പെടാത്തത് അനുവദിക്കുന്നു
വ്യക്തമായി അവഗണിച്ച ഫയൽ തിരുത്തിയെഴുതണം.

--index-output=
$GIT_INDEX_FILE എന്നതിലേക്ക് ഫലങ്ങൾ എഴുതുന്നതിനുപകരം, ഫലമായുള്ള സൂചിക എഴുതുക
പേരിട്ട ഫയൽ. കമാൻഡ് പ്രവർത്തിക്കുമ്പോൾ, യഥാർത്ഥ ഇൻഡക്സ് ഫയൽ ലോക്ക് ചെയ്തിരിക്കുന്നു
പതിവുപോലെ അതേ മെക്കാനിസം. ഫയൽ അനുവദിക്കണം പേരുമാറ്റുക(2) a-ൽ നിന്ന്
സാധാരണ സൂചിക ഫയലിന് അടുത്തായി സൃഷ്ടിക്കുന്ന താൽക്കാലിക ഫയൽ; സാധാരണയായി ഇത് അർത്ഥമാക്കുന്നത്
സൂചിക ഫയലിന്റെ അതേ ഫയൽസിസ്റ്റം ആയിരിക്കണം, നിങ്ങൾ എഴുതേണ്ടതുണ്ട്
ഇൻഡെക്സ് ഫയലും ഇൻഡക്സ് ഔട്ട്പുട്ട് ഫയലും സ്ഥിതി ചെയ്യുന്ന ഡയറക്ടറികളിലേക്കുള്ള അനുമതി.

--നോ-സ്പാർസ്-ചെക്ക്ഔട്ട്
core.sparseCheckout ശരിയാണെങ്കിൽ പോലും വിരളമായ ചെക്ക്ഔട്ട് പിന്തുണ പ്രവർത്തനരഹിതമാക്കുക.

--ശൂന്യം
സൂചികയിലേക്ക് ട്രീ ഒബ്‌ജക്‌റ്റ്(കൾ) വായിക്കുന്നതിന് പകരം അത് ശൂന്യമാക്കുക.


വായിക്കേണ്ട/ലയിപ്പിക്കേണ്ട ട്രീ ഒബ്‌ജക്‌റ്റിന്റെ(കളുടെ) ഐഡി.

ലയിപ്പിക്കുന്നു

-m വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, ജിറ്റിനെ വായന-മരം 3 തരത്തിലുള്ള ലയനം നടത്താം, ഒരു വൃക്ഷം ലയിപ്പിക്കുകയാണെങ്കിൽ
1 വൃക്ഷം മാത്രമേ നൽകിയിട്ടുള്ളൂ, 2 മരങ്ങളുമായി ഫാസ്റ്റ്-ഫോർവേഡ് ലയനം അല്ലെങ്കിൽ 3 മരങ്ങളാണെങ്കിൽ 3-വേ ലയനം
നൽകിയിട്ടുണ്ട്.

സിംഗിൾ വൃക്ഷം ലയിപ്പിക്കുക
1 വൃക്ഷം മാത്രമേ വ്യക്തമാക്കിയിട്ടുള്ളൂ എങ്കിൽ, ജിറ്റിനെ വായന-മരം ഉപയോക്താവ് -m വ്യക്തമാക്കാത്തതുപോലെ പ്രവർത്തിക്കുന്നു,
ഒറിജിനൽ സൂചികയിൽ നൽകിയിരിക്കുന്ന പാത്ത്‌നെയിമിനും അതിന്റെ ഉള്ളടക്കത്തിനും ഒരു എൻട്രി ഉണ്ടെങ്കിൽ
ട്രീയുമായി പാത്ത് പൊരുത്തപ്പെടുന്നു, സൂചികയിൽ നിന്നുള്ള സ്റ്റാറ്റ് വിവരങ്ങൾ ഉപയോഗിക്കുന്നു. (മറ്റുള്ളതിൽ
വാക്കുകൾ, ലയിപ്പിച്ച വൃക്ഷത്തേക്കാൾ സൂചികയുടെ സ്ഥിതിവിവരക്കണക്ക് ()കൾ മുൻഗണന നൽകുന്നു).

അതായത് നിങ്ങൾ ഒരു git read-tree -m ചെയ്താൽ തുടർന്ന് ഒരു git ചെക്ക്ഔട്ട്-ഇൻഡക്സ് -f
-u -a, the ജിറ്റിനെ ചെക്ക്ഔട്ട്-ഇൻഡക്സ് ശരിക്കും മാറിയ കാര്യങ്ങൾ മാത്രം പരിശോധിക്കുന്നു.

എപ്പോൾ അനാവശ്യമായ തെറ്റായ ഹിറ്റുകൾ ഒഴിവാക്കാൻ ഇത് ഉപയോഗിക്കുന്നു ജിറ്റിനെ diff-files പിന്നാലെ ഓടുന്നു ജിറ്റിനെ
വായന-മരം.

രണ്ട് വൃക്ഷം ലയിപ്പിക്കുക
സാധാരണഗതിയിൽ, ഇത് git read-tree -m $H $M ആയി വിളിക്കപ്പെടുന്നു, ഇവിടെ $H ആണ് ഇതിന്റെ തല കമ്മിറ്റ്.
നിലവിലെ റിപ്പോസിറ്ററി, $M എന്നത് ഒരു വിദേശ വൃക്ഷത്തിന്റെ തലയാണ്, അത് $H-നേക്കാൾ മുന്നിലാണ്
(അതായത്, ഞങ്ങൾ അതിവേഗം മുന്നോട്ട് പോകുന്ന അവസ്ഥയിലാണ്).

രണ്ട് മരങ്ങൾ വ്യക്തമാക്കുമ്പോൾ, ഉപയോക്താവ് പറയുന്നു ജിറ്റിനെ വായന-മരം ഇനിപ്പറയുന്നവ:

1. നിലവിലെ സൂചികയും വർക്ക് ട്രീയും $H-ൽ നിന്നാണ് ഉരുത്തിരിഞ്ഞത്, എന്നാൽ ഉപയോക്താവിന് ലോക്കൽ ഉണ്ടായിരിക്കാം
$H മുതൽ അവയിൽ മാറ്റങ്ങൾ.

2. $M-ലേക്ക് ഫാസ്റ്റ് ഫോർവേഡ് ചെയ്യാൻ ഉപയോക്താവ് ആഗ്രഹിക്കുന്നു.

ഈ സാഹചര്യത്തിൽ, git read-tree -m $H $M കമാൻഡ് പ്രാദേശിക മാറ്റങ്ങളൊന്നും നഷ്‌ടപ്പെടുന്നില്ലെന്ന് ഉറപ്പാക്കുന്നു
ഈ "ലയനത്തിന്റെ" ഫലമായി. "ഞാൻ" എന്നത് സൂചിപ്പിക്കുന്ന "മുന്നോട്ട് കൊണ്ടുപോകുക" എന്ന നിയമങ്ങൾ ഇതാ
സൂചിക, "വൃത്തിയുള്ളത്" എന്നാൽ സൂചികയും വർക്ക് ട്രീയും ഒത്തുചേരുന്നു, കൂടാതെ "നിലവിലുണ്ട്"/"ഒന്നുമില്ല" എന്നത് സൂചിപ്പിക്കുന്നത്
നിർദ്ദിഷ്ട പ്രതിബദ്ധതയിൽ ഒരു പാതയുടെ സാന്നിധ്യം:

IHM ഫലം
-------------------------------------------------- -----
0 ഒന്നുമില്ല ഒന്നുമില്ല (സംഭവിക്കുന്നില്ല)
1 ഒന്നും നിലവിലില്ല എം ഉപയോഗിക്കുക
2 ഒന്നും നിലവിലില്ല, സൂചികയിൽ നിന്ന് പാത നീക്കം ചെയ്യുക
3 ഒന്നും നിലവിലില്ല, "പ്രാരംഭ ചെക്ക്ഔട്ട്" ആണെങ്കിൽ M ഉപയോഗിക്കുക,
H == M അല്ലെങ്കിൽ സൂചിക നിലനിർത്തുക
നിലവിലുണ്ട്, പരാജയപ്പെടുന്നു
H!= എം

ക്ലീൻ ഐ==എച്ച്ഐ==എം
------------------
4 അതെ N/AN/A ഒന്നും തന്നെ സൂചിക നിലനിർത്തുന്നില്ല
5 ഇല്ല N/AN/A ഒന്നുമില്ല ഒന്നും സൂക്ഷിക്കരുത് സൂചിക

6 അതെ N/A അതെ ഒന്നും നിലവിലില്ല സൂചിക സൂക്ഷിക്കുക
7 ഇല്ല N/A അതെ ഒന്നും നിലവിലില്ല സൂചിക സൂക്ഷിക്കുക
8 അതെ N/A ഇല്ല ഒന്നും നിലനിൽക്കുന്നില്ല പരാജയം
9 ഇല്ല N/A ഇല്ല ഒന്നും നിലനിൽക്കുന്നില്ല പരാജയം

10 അതെ അതെ N/A നിലവിലില്ല, സൂചികയിൽ നിന്ന് പാത നീക്കം ചെയ്യുന്നില്ല
11 ഇല്ല അതെ N/A നിലവിലില്ല ഒന്നും പരാജയപ്പെടില്ല
12 അതെ ഇല്ല N/A നിലവിലില്ല ഒന്നും പരാജയപ്പെടില്ല
13 ഇല്ല ഇല്ല N/A നിലവിലില്ല ഒന്നും പരാജയപ്പെടില്ല

വൃത്തിയാക്കുക (H==M)
------
14 അതെ നിലവിലുണ്ട് സൂചിക സൂക്ഷിക്കുക
15 നിലവിലില്ല സൂചിക സൂക്ഷിക്കുക

വൃത്തിയാക്കുക I==HI==M (H!=M)
------------------
16 അതെ ഇല്ല ഇല്ല നിലവിലുണ്ട് പരാജയം
17 ഇല്ല ഇല്ല ഇല്ല നിലവിലുണ്ട് പരാജയം
18 അതെ ഇല്ല അതെ നിലവിലുണ്ട് സൂചിക സൂക്ഷിക്കുക
19 ഇല്ല ഇല്ല അതെ നിലവിലുണ്ട് സൂചിക സൂക്ഷിക്കുക
20 അതെ അതെ ഇല്ല നിലവിലില്ല, എം ഉപയോഗിക്കുക
21 ഇല്ല അതെ ഇല്ല നിലവിലുണ്ട് പരാജയം

എല്ലാ "സൂചിക സൂക്ഷിക്കുക" കേസുകളിലും, ഇൻഡക്സ് എൻട്രി യഥാർത്ഥ സൂചിക ഫയലിലേതുപോലെ തന്നെ തുടരും. എങ്കിൽ
പ്രവേശനം കാലികമല്ല, ജിറ്റിനെ വായന-മരം എപ്പോൾ പകർപ്പ് വർക്ക് ട്രീയിൽ കേടുകൂടാതെ സൂക്ഷിക്കുന്നു
-u ഫ്ലാഗിന് കീഴിൽ പ്രവർത്തിക്കുന്നു.

എപ്പോൾ ഈ ഫോം ജിറ്റിനെ വായന-മരം വിജയകരമായി മടങ്ങുന്നു, "ലോക്കൽ" ഏതാണെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും
നിങ്ങൾ വരുത്തിയ മാറ്റങ്ങൾ" git diff-index പ്രവർത്തിപ്പിച്ച് മുന്നോട്ട് കൊണ്ടുപോയി --കാഷെ ചെയ്ത $M. കുറിപ്പ്
ഇത് git diff-index --cached $H ഉൽപ്പാദിപ്പിക്കുമായിരുന്നതുമായി പൊരുത്തപ്പെടണമെന്നില്ല
അത്തരമൊരു രണ്ട് വൃക്ഷം ലയിക്കുന്നതിന് മുമ്പ്. 18-ഉം 19-ഉം കേസുകൾ മൂലമാണ് ഇത് സംഭവിക്കുന്നത് - നിങ്ങൾക്ക് ഇതിനകം ഉണ്ടെങ്കിൽ
$M ലെ മാറ്റങ്ങൾ (ഉദാ: നിങ്ങൾ ഒരു പാച്ച് രൂപത്തിൽ ഇ-മെയിൽ വഴി എടുത്തതാകാം), git diff-index
--cached $H ഈ ലയനത്തിന് മുമ്പ് മാറ്റത്തെക്കുറിച്ച് നിങ്ങളോട് പറയുമായിരുന്നു, പക്ഷേ അത് കാണിക്കില്ല
git diff-index-ൽ --ടു-ട്രീ ലയനത്തിനു ശേഷം $M ഔട്ട്‌പുട്ട് കാഷെ ചെയ്തു.

കേസ് 3 അൽപ്പം ബുദ്ധിമുട്ടുള്ളതും വിശദീകരണം ആവശ്യമാണ്. യുക്തിപരമായി ഈ നിയമത്തിൽ നിന്നുള്ള ഫലം
ഉപയോക്താവ് പാത്ത് നീക്കം ചെയ്യുകയും തുടർന്ന് മാറുകയും ചെയ്‌താൽ പാത നീക്കം ചെയ്യേണ്ടതായിരിക്കണം
ഒരു പുതിയ ശാഖയിലേക്ക്. എന്നിരുന്നാലും അത് പ്രാരംഭ ചെക്ക്ഔട്ട് സംഭവിക്കുന്നത് തടയും, അതിനാൽ
സൂചികയിലെ ഉള്ളടക്കം ശൂന്യമായിരിക്കുമ്പോൾ മാത്രം എം (പുതിയ മരം) ഉപയോഗിക്കുന്നതിന് നിയമം പരിഷ്‌ക്കരിക്കുന്നു.
അല്ലാത്തപക്ഷം $H ഉം $M ഉം ഒരേ പോലെ ഉള്ളിടത്തോളം കാലം പാത നീക്കം ചെയ്യപ്പെടും.

ക്സനുമ്ക്സ-വഴി ലയിപ്പിക്കുക
ഓരോ "സൂചിക" എൻട്രിയിലും രണ്ട് ബിറ്റുകൾ മൂല്യമുള്ള "സ്റ്റേജ്" നിലയുണ്ട്. ഘട്ടം 0 സാധാരണമാണ്, ഇതാണ്
ഏത് തരത്തിലുള്ള സാധാരണ ഉപയോഗത്തിലും നിങ്ങൾക്ക് കാണാൻ കഴിയുന്ന ഒരേയൊരു ഒന്ന്.

എന്നിരുന്നാലും, നിങ്ങൾ ചെയ്യുമ്പോൾ ജിറ്റിനെ വായന-മരം മൂന്ന് മരങ്ങൾക്കൊപ്പം, "ഘട്ടം" 1-ന് ആരംഭിക്കുന്നു.

നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുമെന്നാണ് ഇതിനർത്ഥം

$ git റീഡ്-ട്രീ -എം

കൂടാതെ നിങ്ങൾ എല്ലാം ഉള്ള ഒരു സൂചികയിൽ അവസാനിക്കും "ഘട്ടം1"-ലെ എൻട്രികൾ, എല്ലാം
"ഘട്ടം2" എന്നതിലെ എൻട്രികൾ കൂടാതെ എല്ലാം "ഘട്ടം2" ലെ എൻട്രികൾ. എ നിർവഹിക്കുമ്പോൾ
നിലവിലുള്ള ശാഖയിലേക്ക് മറ്റൊരു ശാഖ ലയിപ്പിക്കുക, ഞങ്ങൾ സാധാരണ പൂർവ്വിക വൃക്ഷം ഉപയോഗിക്കുന്നു
, നിലവിലെ ബ്രാഞ്ച് തല , മറ്റ് ബ്രാഞ്ച് തല .

മാത്രമല്ല, ജിറ്റിനെ വായന-മരം എന്ന പ്രത്യേക-കേസ് ലോജിക് ഉണ്ട്: നിങ്ങൾ ഒരു ഫയൽ കാണുകയാണെങ്കിൽ
ഇനിപ്പറയുന്ന അവസ്ഥകളിൽ എല്ലാ അർത്ഥത്തിലും പൊരുത്തപ്പെടുന്നു, അത് "സ്റ്റേജ്0" ലേക്ക് "തകർച്ച" ചെയ്യുന്നു:

· ഘട്ടം 2 ഉം 3 ഉം സമാനമാണ്; ഒന്നോ രണ്ടോ എടുക്കുക (ഇത് ഒരു വ്യത്യാസവുമില്ല - സമാനമാണ്
ഞങ്ങളുടെ ശാഖയിൽ ഘട്ടം 2 ലും അവരുടെ ബ്രാഞ്ച് ഘട്ടം 3 ലും നടന്നിട്ടുണ്ട്)

· ഘട്ടം 1 ഉം ഘട്ടം 2 ഉം സമാനമാണ്, ഘട്ടം 3 വ്യത്യസ്തമാണ്; ഘട്ടം 3 എടുക്കുക (ഞങ്ങളുടെ ശാഖയിൽ
സ്റ്റേജ് 2 അവരുടെ ശാഖ സ്റ്റേജിൽ ആയിരിക്കുമ്പോൾ സ്റ്റേജ് 1 ൽ പൂർവ്വികർ ഒന്നും ചെയ്തില്ല
3 അതിൽ പ്രവർത്തിച്ചു)

· ഘട്ടം 1 ഉം ഘട്ടം 3 ഉം ഒന്നുതന്നെയാണ്, സ്റ്റേജ് 2 വ്യത്യസ്തമാണ് ടേക്ക് സ്റ്റേജ് 2 (ഞങ്ങൾ ചെയ്തു
അവർ ഒന്നും ചെയ്യാത്തപ്പോൾ എന്തോ)

ദി ജിറ്റിനെ എഴുത്ത്-മരം കമാൻഡ് ഒരു അസംബന്ധ വൃക്ഷം എഴുതാൻ വിസമ്മതിക്കുന്നു, അത് പരാതിപ്പെടും
സ്റ്റേജ് 0 അല്ലാത്ത ഒരു എൻട്രി കാണുകയാണെങ്കിൽ ലയിപ്പിക്കാത്ത എൻട്രികൾ.

ശരി, ഇതെല്ലാം തികച്ചും അസംബന്ധ നിയമങ്ങളുടെ ഒരു ശേഖരം പോലെ തോന്നുന്നു, പക്ഷേ ഇത് യഥാർത്ഥമാണ്
വേഗത്തിലുള്ള ലയനം നടത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നതെന്തും. വിവിധ ഘട്ടങ്ങൾ പ്രതിനിധീകരിക്കുന്നു
"ഫലവൃക്ഷം" (ഘട്ടം 0, അല്ലെങ്കിൽ "ലയിപ്പിച്ചത്"), യഥാർത്ഥ വൃക്ഷം (ഘട്ടം 1, അല്ലെങ്കിൽ "ഒറിഗ്"), കൂടാതെ
നിങ്ങൾ ലയിപ്പിക്കാൻ ശ്രമിക്കുന്ന രണ്ട് മരങ്ങൾ (യഥാക്രമം ഘട്ടം 2 ഉം 3 ഉം).

1, 2, 3 ഘട്ടങ്ങളുടെ ക്രമം (അതിനാൽ മൂന്നിന്റെ ക്രമം കമാൻഡ്-ലൈൻ
ആർഗ്യുമെന്റുകൾ) നിങ്ങൾ ഇതിനകം ഉള്ള ഒരു സൂചിക ഫയലുമായി 3-വേ ലയനം ആരംഭിക്കുമ്പോൾ പ്രധാനമാണ്
ജനവാസമുള്ള. അൽഗോരിതം എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ഒരു രൂപരേഖ ഇതാ:

· മൂന്ന് മരങ്ങളിലും ഒരേ ഫോർമാറ്റിൽ ഒരു ഫയൽ നിലവിലുണ്ടെങ്കിൽ, അത് യാന്ത്രികമാകും
വഴി "ലയിപ്പിച്ച" അവസ്ഥയിലേക്ക് തകരുക ജിറ്റിനെ വായന-മരം.

· ഉള്ള ഒരു ഫയൽ എന്തെങ്കിലും മൂന്ന് മരങ്ങളിലെ വ്യത്യാസം വ്യത്യസ്തമായി നിലനിൽക്കും
സൂചികയിലെ എൻട്രികൾ. അത് എങ്ങനെ നീക്കം ചെയ്യണമെന്ന് തീരുമാനിക്കേണ്ടത് "പോർസലൈൻ നയം" ആണ്
നോൺ-0 ഘട്ടങ്ങൾ, ഒരു ലയിപ്പിച്ച പതിപ്പ് ചേർക്കുക.

ഈ എല്ലാ വിവരങ്ങളും ഉപയോഗിച്ച് സൂചിക ഫയൽ സംരക്ഷിക്കുകയും പുനഃസ്ഥാപിക്കുകയും ചെയ്യുന്നു, അതിനാൽ നിങ്ങൾക്ക് കാര്യങ്ങൾ ലയിപ്പിക്കാനാകും
1/2/3 ഘട്ടങ്ങളിൽ എൻട്രികൾ ഉള്ളിടത്തോളം (അതായത്, "ലയിപ്പിക്കാത്തത്"
എൻട്രികൾ") നിങ്ങൾക്ക് ഫലം എഴുതാൻ കഴിയില്ല. അതിനാൽ ഇപ്പോൾ ലയന അൽഗോരിതം യഥാർത്ഥത്തിൽ അവസാനിക്കുന്നു
ലളിതം:

· നിങ്ങൾ സൂചികയെ ക്രമത്തിൽ നടത്തുകയും ഘട്ടം 0-ന്റെ എല്ലാ എൻട്രികളും അവഗണിക്കുകയും ചെയ്യുന്നു
ഇതിനകം ചെയ്തു.

നിങ്ങൾ ഒരു "stage1" കണ്ടെത്തുകയാണെങ്കിൽ, എന്നാൽ "stage2" അല്ലെങ്കിൽ "stage3" എന്നിവയുമായി പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, നിങ്ങൾക്കറിയാം
രണ്ട് മരങ്ങളിൽ നിന്നും നീക്കം ചെയ്തു (അത് യഥാർത്ഥ മരത്തിൽ മാത്രമേ ഉണ്ടായിരുന്നുള്ളൂ), നിങ്ങൾ നീക്കം ചെയ്യുക
ആ എൻട്രി.

യോജിച്ച "stage2", "stage3" എന്നീ മരങ്ങൾ നിങ്ങൾ കണ്ടെത്തുകയാണെങ്കിൽ, അവയിലൊന്ന് നീക്കം ചെയ്യുക, ഒപ്പം
മറ്റൊന്ന് "stage0" എൻട്രി ആക്കി മാറ്റുക. പൊരുത്തമുള്ള "stage1" എൻട്രി ഉണ്ടെങ്കിൽ അത് നീക്കം ചെയ്യുക
നിലവിലുമുണ്ട്. .. എല്ലാ സാധാരണ നിസ്സാര നിയമങ്ങളും ..

നിങ്ങൾ സാധാരണയായി ഉപയോഗിക്കും ജിറ്റിനെ ലയനം-സൂചിക കൂടെ വിതരണം ചെയ്തു ജിറ്റിനെ ലയിപ്പിക്കുക-ഒരു ഫയൽ ഇത് അവസാനമായി ചെയ്യാൻ
ഘട്ടം. സ്ക്രിപ്റ്റ് ഓരോ പാതയും ലയിപ്പിക്കുമ്പോൾ പ്രവർത്തിക്കുന്ന ട്രീയിലെ ഫയലുകൾ അപ്ഡേറ്റ് ചെയ്യുന്നു
വിജയകരമായ ഒരു ലയനത്തിന്റെ അവസാനം.

നിങ്ങൾ ഇതിനകം ജനസംഖ്യയുള്ള ഒരു സൂചിക ഫയലുമായി 3-വഴി ലയനം ആരംഭിക്കുമ്പോൾ, അത് അനുമാനിക്കപ്പെടുന്നു
അത് നിങ്ങളുടെ വർക്ക് ട്രീയിലെ ഫയലുകളുടെ അവസ്ഥയെ പ്രതിനിധീകരിക്കുന്നു, നിങ്ങൾക്ക് ഫയലുകൾ പോലും ഉണ്ടായിരിക്കാം
സൂചിക ഫയലിൽ രേഖപ്പെടുത്താത്ത മാറ്റങ്ങളോടെ. ഈ സംസ്ഥാനം ആണെന്ന് കൂടുതൽ അനുമാനിക്കപ്പെടുന്നു
സ്റ്റേജ് 2 മരത്തിൽ നിന്ന് "ഉത്ഭവിച്ചത്". ഒരു എൻട്രി കണ്ടെത്തിയാൽ 3-വേ ലയനം പ്രവർത്തിക്കാൻ വിസമ്മതിക്കുന്നു
ഘട്ടം 2-മായി പൊരുത്തപ്പെടാത്ത യഥാർത്ഥ സൂചിക ഫയൽ.

നിങ്ങളുടെ വർക്ക്-ഇൻ-പ്രോഗ്രസ് മാറ്റങ്ങൾ നഷ്‌ടപ്പെടാതിരിക്കാനും നിങ്ങളുടേത് മിക്സ് ചെയ്യാതിരിക്കാനുമാണ് ഇത് ചെയ്യുന്നത്
ഒരു ബന്ധമില്ലാത്ത ലയനത്തിൽ ക്രമരഹിതമായ മാറ്റങ്ങൾ. ഉദാഹരിക്കാൻ, നിങ്ങൾ എന്തിൽ നിന്നാണ് തുടങ്ങുന്നതെന്ന് കരുതുക
നിങ്ങളുടെ സംഭരണിയിൽ അവസാനമായി പ്രതിജ്ഞാബദ്ധമാണ്:

$ JC=`git rev-parse --verify "HEAD^0"`
$ git ചെക്ക്ഔട്ട്-ഇൻഡക്സ് -f -u -a $JC

നിങ്ങൾ റൺ ചെയ്യാതെ ക്രമരഹിതമായ എഡിറ്റുകൾ ചെയ്യുന്നു ജിറ്റിനെ അപ്ഡേറ്റ്-ഇൻഡക്സ്. എന്നിട്ട് നിങ്ങൾ ശ്രദ്ധിക്കുന്നത് അതിന്റെ അറ്റം
നിങ്ങൾ അവനിൽ നിന്ന് പിൻവലിച്ചതിന് ശേഷം നിങ്ങളുടെ "അപ്സ്ട്രീം" മരം മുന്നേറി:

$ git കൊണ്ടുവരിക git://.... linus
$ LT=`git rev-parse FETCH_HEAD`

നിങ്ങളുടെ വർക്ക് ട്രീ ഇപ്പോഴും നിങ്ങളുടെ ഹെഡ് ($JC) അടിസ്ഥാനമാക്കിയുള്ളതാണ്, എന്നാൽ അതിനുശേഷം നിങ്ങൾക്ക് ചില എഡിറ്റുകൾ ഉണ്ട്. മൂന്ന്-വഴി
നിങ്ങൾ $JC ന് ശേഷം സൂചിക എൻട്രികൾ ചേർക്കുകയോ പരിഷ്ക്കരിക്കുകയോ ചെയ്തിട്ടില്ലെന്ന് ലയനം ഉറപ്പാക്കുന്നു, നിങ്ങളാണെങ്കിൽ
ഇല്ല, അപ്പോൾ ശരിയായ കാര്യം ചെയ്യുന്നു. അതിനാൽ ഇനിപ്പറയുന്ന ക്രമം ഉപയോഗിച്ച്:

$ git read-tree -m -u `git merge-base $JC $LT` $JC $LT
$ git merge-index git-merge-one-file -a
$ എക്കോ "ലിനസുമായി ലയിപ്പിക്കുക" | \
git commit-tree `git write-tree` -p $JC -p $LT

നിങ്ങളുടെ ജോലി പുരോഗമിക്കാതെ തന്നെ $JC-യും $LT-യും തമ്മിലുള്ള ശുദ്ധമായ ലയനമാണ് നിങ്ങൾ ചെയ്യേണ്ടത്
മാറ്റങ്ങൾ, നിങ്ങളുടെ വർക്ക് ട്രീ ലയനത്തിന്റെ ഫലത്തിലേക്ക് അപ്ഡേറ്റ് ചെയ്യപ്പെടും.

എന്നിരുന്നാലും, വർക്കിംഗ് ട്രീയിൽ നിങ്ങൾക്ക് പ്രാദേശിക മാറ്റങ്ങൾ ഉണ്ടെങ്കിൽ അത് ഇത് തിരുത്തിയെഴുതപ്പെടും
ലയിപ്പിക്കുക, ജിറ്റിനെ വായന-മരം നിങ്ങളുടെ മാറ്റങ്ങൾ നഷ്‌ടപ്പെടാതിരിക്കാൻ പ്രവർത്തിക്കാൻ വിസമ്മതിക്കും.

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

വിരളമായ ചെക്ക് ഔട്ട്

"സ്പാർസ് ചെക്ക്ഔട്ട്" പ്രവർത്തനക്ഷമമായ ഡയറക്‌ടറി പോപ്പുലേറ്റ് ചെയ്യാൻ അനുവദിക്കുന്നു. ഇത് ഉപയോഗിക്കുന്നു
skip-worktree bit (കാണുക git-update-index(1)) ഒരു ഫയൽ പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് Git-നോട് പറയാൻ
ഡയറക്ടറി നോക്കേണ്ടതാണ്.

ജിറ്റിനെ വായന-മരം മറ്റ് ലയന-അടിസ്ഥാന കമാൻഡുകൾ (ജിറ്റിനെ ലയിപ്പിക്കുക, ജിറ്റിനെ ചെക്ക് ഔട്ട്...) സഹായിക്കാം
skip-worktree ബിറ്റ്മാപ്പും വർക്കിംഗ് ഡയറക്ടറി അപ്ഡേറ്റും പരിപാലിക്കുന്നു.
$GIT_DIR/info/sparse-checkout എന്നത് skip-worktree റഫറൻസ് ബിറ്റ്മാപ്പ് നിർവചിക്കാൻ ഉപയോഗിക്കുന്നു. എപ്പോൾ
ജിറ്റിനെ വായന-മരം പ്രവർത്തന ഡയറക്‌ടറി അപ്‌ഡേറ്റ് ചെയ്യേണ്ടതുണ്ട്, അത് സ്‌കിപ്പ്-വർക്ക്‌ട്രീ ബിറ്റ് ഇൻ റീസെറ്റ് ചെയ്യുന്നു
.gitignore ഫയലുകളുടെ അതേ വാക്യഘടന ഉപയോഗിക്കുന്ന ഈ ഫയലിനെ അടിസ്ഥാനമാക്കിയുള്ള സൂചിക. ഒരു എൻട്രി എങ്കിൽ
ഈ ഫയലിലെ ഒരു പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നു, ആ എൻട്രിയിൽ skip-worktree സജ്ജീകരിക്കില്ല. അല്ലെങ്കിൽ,
skip-worktree സജ്ജീകരിക്കും.

തുടർന്ന് അത് പുതിയ skip-worktree മൂല്യത്തെ മുമ്പത്തേതുമായി താരതമ്യം ചെയ്യുന്നു. skip-worktree തിരിഞ്ഞാൽ
സെറ്റ് മുതൽ അൺസെറ്റ് വരെ, അത് അനുബന്ധ ഫയൽ തിരികെ ചേർക്കും. ഇത് സജ്ജീകരിക്കാത്തതിൽ നിന്ന് സെറ്റിലേക്ക് മാറുകയാണെങ്കിൽ,
ആ ഫയൽ നീക്കം ചെയ്യപ്പെടും.

$GIT_DIR/info/sparse-checkout സാധാരണയായി ഏത് ഫയലുകളിലാണെന്ന് വ്യക്തമാക്കാൻ ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾക്ക് കഴിയും
ഫയലുകൾ എന്താണെന്നും വ്യക്തമാക്കുക അല്ല ഇൻ, നെഗേറ്റ് പാറ്റേണുകൾ ഉപയോഗിച്ച്. ഉദാഹരണത്തിന്, ഫയൽ നീക്കം ചെയ്യാൻ
ആവശ്യമില്ലാത്ത:

/*
!ആവശ്യമില്ലാത്ത

നിങ്ങൾക്ക് ഇനി ആവശ്യമില്ലാത്തപ്പോൾ വർക്കിംഗ് ഡയറക്‌ടറി പൂർണ്ണമായി പുനർനിർമ്മിക്കുക എന്നതാണ് മറ്റൊരു തന്ത്രപരമായ കാര്യം
വിരളമായ ചെക്ക്ഔട്ട്. നിങ്ങൾക്ക് "സ്പാർസ് ചെക്ക്ഔട്ട്" അപ്രാപ്തമാക്കാൻ കഴിയില്ല കാരണം skip-worktree bits ആണ്
ഇപ്പോഴും സൂചികയിലുണ്ട്, നിങ്ങളുടെ പ്രവർത്തന ഡയറക്‌ടറിയിൽ ഇപ്പോഴും ജനസംഖ്യ കുറവാണ്. നീ ചെയ്തിരിക്കണം
$GIT_DIR/info/sparse-checkout ഫയൽ ഉള്ളടക്കം ഉപയോഗിച്ച് വർക്കിംഗ് ഡയറക്‌ടറി വീണ്ടും ജനകീയമാക്കുക
താഴെ:

/*

അപ്പോൾ നിങ്ങൾക്ക് വിരളമായ ചെക്ക്ഔട്ട് പ്രവർത്തനരഹിതമാക്കാം. വിരളമായ ചെക്ക്ഔട്ട് പിന്തുണ ജിറ്റിനെ വായന-മരം സമാനവും
കമാൻഡുകൾ ഡിഫോൾട്ടായി പ്രവർത്തനരഹിതമാക്കിയിരിക്കുന്നു. ലഭിക്കാൻ നിങ്ങൾ core.sparseCheckout ഓണാക്കേണ്ടതുണ്ട്
വിരളമായ ചെക്ക്ഔട്ട് പിന്തുണ.

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