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

പട്ടിക:

NAME

git-stash - ഒരു വൃത്തികെട്ട വർക്കിംഗ് ഡയറക്ടറിയിൽ മാറ്റങ്ങൾ സൂക്ഷിക്കുക

സിനോപ്സിസ്

ജിറ്റിനെ സ്റ്റാഷ് പട്ടിക [ ]
ജിറ്റിനെ സ്റ്റാഷ് കാണിക്കുക [ ]
ജിറ്റിനെ സ്റ്റാഷ് ഡ്രോപ്പ് [-q|--നിശബ്ദത] [ ]
ജിറ്റിനെ സ്റ്റാഷ് ( പോപ്പ് | പ്രയോഗിക്കുക ) [--സൂചിക] [-q|--ശാന്തം] [ ]
ജിറ്റിനെ സ്റ്റാഷ് ശാഖ [ ]
ജിറ്റിനെ സ്റ്റാഷ് [-p|--പാച്ച് സംരക്ഷിക്കുക] [-k|--[no-]keep-index] [-q|--quiet]
[-u|--അൺട്രാക്ക് ചെയ്യാത്തത്] [-a|--എല്ലാം] [ ]]
ജിറ്റിനെ സ്റ്റാഷ് വ്യക്തമാക്കുക
ജിറ്റിനെ സ്റ്റാഷ് സൃഷ്ടിക്കാൻ [ ]
ജിറ്റിനെ സ്റ്റാഷ് [-m|--സന്ദേശം സംഭരിക്കുക ] [-q|--ശാന്തം]

വിവരണം

പ്രവർത്തിക്കുന്ന ഡയറക്‌ടറിയുടെ നിലവിലെ അവസ്ഥ രേഖപ്പെടുത്താൻ താൽപ്പര്യപ്പെടുമ്പോൾ git stash ഉപയോഗിക്കുക
സൂചിക, എന്നാൽ ഒരു ക്ലീൻ വർക്കിംഗ് ഡയറക്ടറിയിലേക്ക് മടങ്ങാൻ ആഗ്രഹിക്കുന്നു. കമാൻഡ് നിങ്ങളുടെ ലോക്കൽ സംരക്ഷിക്കുന്നു
HEAD പ്രതിബദ്ധതയുമായി പൊരുത്തപ്പെടുന്നതിന് വർക്കിംഗ് ഡയറക്‌ടറി മാറ്റുകയും മാറ്റുകയും ചെയ്യുന്നു.

ഈ കമാൻഡ് വഴി മാറ്റിവെച്ച പരിഷ്കാരങ്ങൾ git സ്റ്റാഷ് ലിസ്റ്റ് ഉപയോഗിച്ച് ലിസ്റ്റ് ചെയ്യാവുന്നതാണ്,
ജിറ്റ് സ്റ്റാഷ് ഷോ ഉപയോഗിച്ച് പരിശോധിച്ച് പുനഃസ്ഥാപിച്ചു (മറ്റൊരു പ്രതിബദ്ധതയ്ക്ക് മുകളിൽ)
git സ്റ്റാഷ് ഉപയോഗിച്ച് പ്രയോഗിക്കുക. വാദങ്ങളൊന്നുമില്ലാതെ git stash എന്ന് വിളിക്കുന്നത് git stash ന് തുല്യമാണ്
രക്ഷിക്കും. ഒരു സ്റ്റാഷ് ഡിഫോൾട്ടായി "WIP ഓൺ" എന്ന് ലിസ്റ്റ് ചെയ്തിരിക്കുന്നു ശാഖനാമം ...", എന്നാൽ നിങ്ങൾക്ക് കൂടുതൽ നൽകാം
നിങ്ങൾ ഒരെണ്ണം സൃഷ്ടിക്കുമ്പോൾ കമാൻഡ് ലൈനിൽ വിവരണാത്മക സന്ദേശം.

നിങ്ങൾ സൃഷ്‌ടിച്ച ഏറ്റവും പുതിയ സ്‌റ്റാഷ് refs/stash-ൽ സംഭരിച്ചിരിക്കുന്നു; പഴയ സ്റ്റേഷുകൾ കാണപ്പെടുന്നു
ഈ റഫറൻസിന്റെ റീലോഗ്, സാധാരണ റിലോഗ് വാക്യഘടന ഉപയോഗിച്ച് പേര് നൽകാം (ഉദാ: stash@{0} ആണ്
ഏറ്റവും സമീപകാലത്ത് സൃഷ്‌ടിച്ച സ്‌റ്റാഷ്, സ്‌റ്റാഷ്@{1} ആണ് അതിന് മുമ്പുള്ള സ്‌റ്റാഷ്‌@{2.hours.ago}
സാധ്യമാണ്).

ഓപ്ഷനുകൾ

സംരക്ഷിക്കുക [-p|--patch] [-k|--[no-]keep-index] [-u|--include-untracked] [-a|--all] [-q|--quiet]
[ ]
നിങ്ങളുടെ പ്രാദേശിക പരിഷ്കാരങ്ങൾ പുതിയതിലേക്ക് സംരക്ഷിക്കുക സ്റ്റാഷ്, ഒപ്പം ജിറ്റ് റീസെറ്റ് പ്രവർത്തിപ്പിക്കുക --അവ പഴയപടിയാക്കാൻ പ്രയാസമാണ്.
ദി ഭാഗം ഓപ്ഷണൽ ആണ് കൂടാതെ സ്റ്റാഷ് ചെയ്ത അവസ്ഥയ്‌ക്കൊപ്പം വിവരണം നൽകുന്നു.
വേഗത്തിൽ ഒരു സ്നാപ്പ്ഷോട്ട് നിർമ്മിക്കുന്നതിന്, നിങ്ങൾക്ക് ഒഴിവാക്കാവുന്നതാണ് രണ്ടും "സംരക്ഷിക്കുക" ഒപ്പം , എന്നാൽ നൽകുന്നത് മാത്രം
തെറ്റായി എഴുതിയ ഒരു ഉപകമാൻഡ് ഉണ്ടാക്കുന്നതിൽ നിന്ന് തടയാൻ ഈ പ്രവർത്തനത്തെ ട്രിഗർ ചെയ്യുന്നില്ല
ഒരു ആവശ്യമില്ലാത്ത ശേഖരം.

--keep-index ഓപ്‌ഷൻ ഉപയോഗിക്കുകയാണെങ്കിൽ, സൂചികയിൽ ഇതിനകം ചേർത്ത എല്ലാ മാറ്റങ്ങളും അവശേഷിക്കുന്നു
കേടുകൂടാതെയിരിക്കും.

--include-untracked ഓപ്‌ഷൻ ഉപയോഗിക്കുകയാണെങ്കിൽ, ട്രാക്ക് ചെയ്യാത്ത എല്ലാ ഫയലുകളും സ്‌റ്റാഷ് ചെയ്യപ്പെടും
പിന്നീട് ജിറ്റ് ക്ലീൻ ഉപയോഗിച്ച് വൃത്തിയാക്കി, വർക്കിംഗ് ഡയറക്‌ടറി വളരെ വൃത്തിയുള്ള അവസ്ഥയിലാക്കി.
പകരം --all ഓപ്‌ഷൻ ഉപയോഗിക്കുകയാണെങ്കിൽ, അവഗണിക്കപ്പെട്ട ഫയലുകൾ സ്‌റ്റാഷ് ചെയ്‌ത് വൃത്തിയാക്കപ്പെടും
ട്രാക്ക് ചെയ്യാത്ത ഫയലുകൾക്ക് പുറമേ.

--patch ഉപയോഗിച്ച്, നിങ്ങൾക്ക് HEAD ഉം the ഉം തമ്മിലുള്ള വ്യത്യാസത്തിൽ നിന്ന് സംവേദനാത്മകമായി ഹങ്കുകൾ തിരഞ്ഞെടുക്കാനാകും
പണിയെടുക്കുന്ന വൃക്ഷം സൂക്ഷിക്കണം. സ്റ്റാഷ് എൻട്രി നിർമ്മിച്ചിരിക്കുന്നത് അതിന്റെ സൂചിക നിലയിലാണ്
നിങ്ങളുടെ റിപ്പോസിറ്ററിയുടെ സൂചിക നിലയ്ക്ക് സമാനമാണ്, അതിന്റെ വർക്ക്ട്രീയിൽ മാത്രം അടങ്ങിയിരിക്കുന്നു
നിങ്ങൾ സംവേദനാത്മകമായി തിരഞ്ഞെടുത്ത മാറ്റങ്ങൾ. തിരഞ്ഞെടുത്ത മാറ്റങ്ങൾ പിന്നീട് റോൾ ബാക്ക് ചെയ്യുന്നു
നിങ്ങളുടെ വർക്ക് ട്രീ. "ഇന്ററാക്ടീവ് മോഡ്" എന്ന വിഭാഗം കാണുക git-add(1) എങ്ങനെയെന്ന് പഠിക്കാൻ
--patch മോഡ് പ്രവർത്തിപ്പിക്കുക.

--patch ഓപ്ഷൻ സൂചിപ്പിക്കുന്നത് --keep-index എന്നാണ്. ഇത് മറികടക്കാൻ നിങ്ങൾക്ക് --no-keep-index ഉപയോഗിക്കാം.

പട്ടിക [ ]
നിങ്ങൾക്ക് നിലവിൽ ഉള്ള സ്‌റ്റാഷുകൾ ലിസ്റ്റ് ചെയ്യുക. ഓരോന്നും സ്റ്റാഷ് അതിന്റെ പേരിനൊപ്പം പട്ടികപ്പെടുത്തിയിരിക്കുന്നു (ഉദാ
stash@{0} എന്നത് ഏറ്റവും പുതിയ സ്‌റ്റാഷ് ആണ്, സ്റ്റാഷ്@{1} എന്നത് മുമ്പത്തേതാണ്, മുതലായവ), ഇതിന്റെ പേര്
സ്റ്റാഷ് ഉണ്ടാക്കിയപ്പോൾ നിലവിലുള്ള ബ്രാഞ്ച്, കമ്മിറ്റിന്റെ ഒരു ചെറിയ വിവരണം
സ്‌റ്റാഷ് അടിസ്ഥാനമാക്കിയുള്ളതായിരുന്നു.

stash@{0}: സമർപ്പിക്കുമ്പോൾ WIP: 6ebd0e2... git-stash ഡോക്യുമെന്റേഷൻ അപ്‌ഡേറ്റ് ചെയ്യുക
stash@{1}: മാസ്റ്ററിൽ: 9cc0589... git-stash ചേർക്കുക

എന്നതിന് ബാധകമായ ഓപ്ഷനുകൾ കമാൻഡ് എടുക്കുന്നു ജിറ്റിനെ ലോഗ് കാണിക്കുന്നത് നിയന്ത്രിക്കാനുള്ള കമാൻഡ്
എങ്ങനെ. കാണുക git-log(1).

കാണിക്കുക [ ]
സ്‌റ്റാഷിൽ രേഖപ്പെടുത്തിയിരിക്കുന്ന മാറ്റങ്ങൾ സ്‌റ്റേഷ് ചെയ്‌ത നിലയും അതിന്റെ സ്‌റ്റേറ്റും തമ്മിലുള്ള വ്യത്യാസമായി കാണിക്കുക
യഥാർത്ഥ രക്ഷകർത്താവ്. ഇല്ല എപ്പോൾ നൽകിയിരിക്കുന്നു, ഏറ്റവും പുതിയത് കാണിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, ദി
കമാൻഡ് ഡിഫ്സ്റ്റാറ്റ് കാണിക്കുന്നു, പക്ഷേ അത് അറിയാവുന്ന ഏത് ഫോർമാറ്റും സ്വീകരിക്കും ജിറ്റിനെ ഡിഫ്എഫ് (ഉദാ, git
ഏറ്റവും പുതിയ രണ്ടാമത്തെ സ്റ്റാഷ് പാച്ച് രൂപത്തിൽ കാണുന്നതിന് stash show -p stash@{1}). നിങ്ങൾക്ക് കഴിയും
സ്ഥിരസ്ഥിതി മാറ്റാൻ stash.showStat കൂടാതെ/അല്ലെങ്കിൽ stash.showPatch കോൺഫിഗറേഷൻ വേരിയബിളുകൾ ഉപയോഗിക്കുക
പെരുമാറ്റം.

പോപ്പ് [--സൂചിക] [-q|--ശാന്തം] [ ]
സ്‌റ്റാഷ് ലിസ്റ്റിൽ നിന്ന് ഒരൊറ്റ സ്‌റ്റേഷ് ചെയ്‌ത അവസ്ഥ നീക്കം ചെയ്‌ത് കറന്റിനു മുകളിൽ പ്രയോഗിക്കുക
വർക്കിംഗ് ട്രീ സ്റ്റേറ്റ്, അതായത്, ജിറ്റ് സ്റ്റാഷ് സേവിന്റെ വിപരീത പ്രവർത്തനം നടത്തുക. ജോലി ചെയ്യുന്നത്
ഡയറക്ടറി സൂചികയുമായി പൊരുത്തപ്പെടണം.

സംസ്ഥാനം പ്രയോഗിക്കുന്നത് വൈരുദ്ധ്യങ്ങളുമായി പരാജയപ്പെടാം; ഈ സാഹചര്യത്തിൽ, അതിൽ നിന്ന് നീക്കം ചെയ്യപ്പെടുന്നില്ല
സ്റ്റാഷ് ലിസ്റ്റ്. നിങ്ങൾ വൈരുദ്ധ്യങ്ങൾ കൈകൊണ്ട് പരിഹരിക്കുകയും git stash drop മാനുവലായി വിളിക്കുകയും വേണം
അതിനുശേഷം.

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

ഇല്ല എപ്പോൾ നൽകിയിരിക്കുന്നു, stash@{0} അനുമാനിക്കപ്പെടുന്നു, അല്ലാത്തപക്ഷം ഒരു റഫറൻസ് ആയിരിക്കണം
ഫോമിന്റെ സ്റ്റാഷ്@{ }.

പ്രയോഗിക്കുക [--സൂചിക] [-q|--ശാന്തം] [ ]
പോപ്പ് പോലെ, എന്നാൽ സ്റ്റാഷ് ലിസ്റ്റിൽ നിന്ന് സംസ്ഥാനം നീക്കം ചെയ്യരുത്. പോപ്പിൽ നിന്ന് വ്യത്യസ്തമായി, ഒരുപക്ഷേ
സ്റ്റാഷ് സേവ് അല്ലെങ്കിൽ സ്റ്റാഷ് ക്രിയേറ്റ് വഴി സൃഷ്‌ടിച്ച പ്രതിബദ്ധത പോലെ തോന്നിക്കുന്ന ഏതൊരു പ്രതിബദ്ധതയും.

ശാഖ [ ]
എന്ന പേരിൽ ഒരു പുതിയ ബ്രാഞ്ച് സൃഷ്ടിക്കുകയും പരിശോധിക്കുകയും ചെയ്യുന്നു എന്ന പ്രതിബദ്ധതയിൽ നിന്ന് ആരംഭിക്കുന്നു
ഏത് യഥാർത്ഥത്തിൽ സൃഷ്ടിച്ചത്, അതിൽ രേഖപ്പെടുത്തിയിരിക്കുന്ന മാറ്റങ്ങൾ ബാധകമാണ് വരെ
പുതിയ പ്രവർത്തന വൃക്ഷവും സൂചികയും. അത് വിജയിക്കുകയാണെങ്കിൽ, ഒപ്പം യുടെ ഒരു റഫറൻസ് ആണ്
ഫോം സ്റ്റാഷ്@{ }, അത് പിന്നീട് ഡ്രോപ്പ് ചെയ്യുന്നു . ഇല്ല എപ്പോൾ നൽകിയിരിക്കുന്നു, ബാധകമാണ്
ഏറ്റവും പുതിയത്.

നിങ്ങൾ ജിറ്റ് സ്റ്റാഷ് സേവ് നടത്തിയ ബ്രാഞ്ച് മതിയായ മാറ്റമുണ്ടെങ്കിൽ ഇത് ഉപയോഗപ്രദമാണ്
പൊരുത്തക്കേടുകൾ കാരണം git stash പ്രയോഗിക്കുന്നത് പരാജയപ്പെടുന്നു. സ്റ്റാഷ് മുകളിൽ പ്രയോഗിക്കുന്നതിനാൽ
ഗിറ്റ് സ്റ്റാഷ് പ്രവർത്തിപ്പിക്കുമ്പോൾ തലയിലുണ്ടായിരുന്ന കമ്മിറ്റ്, അത് യഥാർത്ഥത്തിൽ സൂക്ഷിച്ചിരുന്നതിനെ പുനഃസ്ഥാപിക്കുന്നു
സംഘർഷങ്ങളില്ലാത്ത സംസ്ഥാനം.

വ്യക്തമാക്കുക
എല്ലാ സ്തംഭനാവസ്ഥകളും നീക്കം ചെയ്യുക. ആ സംസ്ഥാനങ്ങൾ പിന്നീട് വെട്ടിമാറ്റലിന് വിധേയമാകുമെന്നത് ശ്രദ്ധിക്കുക,
വീണ്ടെടുക്കൽ അസാധ്യമായേക്കാം (കാണുക ഉദാഹരണങ്ങൾ സാധ്യമായ ഒരു തന്ത്രത്തിനായി താഴെ).

ഡ്രോപ്പ് [-q|--നിശബ്ദത] [ ]
സ്റ്റാഷ് ലിസ്റ്റിൽ നിന്ന് ഒരു ഒറ്റ സ്റ്റേഷ് നീക്കം ചെയ്യുക. ഇല്ല എപ്പോൾ നൽകിയിരിക്കുന്നു, അത്
ഏറ്റവും പുതിയത് നീക്കം ചെയ്യുന്നു. അതായത് stash@{0}, അല്ലെങ്കിൽ സാധുവായ ഒരു സ്റ്റാഷ് ലോഗ് ആയിരിക്കണം
ഫോമിന്റെ റഫറൻസ് സ്റ്റാഷ്@{ }.

സൃഷ്ടിക്കാൻ
ഒരു സ്‌റ്റാഷ് സൃഷ്‌ടിക്കുക (ഇത് ഒരു സാധാരണ കമ്മിറ്റ് ഒബ്‌ജക്‌റ്റാണ്) കൂടാതെ അതിന്റെ ഒബ്‌ജക്‌റ്റ് നാമം തിരികെ നൽകുക
ref നെയിംസ്പേസിൽ എവിടെയും അത് സംഭരിക്കുന്നു. ഇത് സ്ക്രിപ്റ്റുകൾക്ക് ഉപയോഗപ്രദമാകാൻ ഉദ്ദേശിച്ചുള്ളതാണ്.
നിങ്ങൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന കമാൻഡ് ആയിരിക്കില്ല ഇത്; മുകളിൽ "സംരക്ഷിക്കുക" കാണുക.

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

DISCUSSION

ഒരു സ്റ്റാഷിനെ പ്രതിനിധീകരിക്കുന്നത് ഒരു കമ്മിറ്റായി പ്രതിനിധീകരിക്കുന്നു, അതിന്റെ മരം പ്രവർത്തന ഡയറക്ടറിയുടെ അവസ്ഥ രേഖപ്പെടുത്തുന്നു,
സ്റ്റാഷ് സൃഷ്‌ടിച്ചപ്പോൾ HEAD-ലെ പ്രതിബദ്ധതയാണ് അതിന്റെ ആദ്യ രക്ഷിതാവ്. എന്ന വൃക്ഷം
രണ്ടാമത്തെ രക്ഷകർത്താവ് സ്റ്റാഷ് നിർമ്മിക്കുമ്പോൾ സൂചികയുടെ അവസ്ഥ രേഖപ്പെടുത്തുന്നു, അത് നിർമ്മിക്കുന്നു a
തല കമ്മിറ്റിന്റെ കുട്ടി. വംശാവലി ഗ്രാഫ് ഇതുപോലെ കാണപ്പെടുന്നു:

.----ഡബ്ല്യു
/ /
-----എച്ച്----ഐ

ഇവിടെ H എന്നത് HEAD കമ്മിറ്റ് ആണ്, I എന്നത് സൂചികയുടെ അവസ്ഥ രേഖപ്പെടുത്തുന്ന ഒരു കമ്മിറ്റാണ്, W എന്നത് a
ജോലി ചെയ്യുന്ന മരത്തിന്റെ അവസ്ഥ രേഖപ്പെടുത്തുന്ന കമ്മിറ്റ്.

ഉദാഹരണങ്ങൾ

വൃത്തികെട്ട മരത്തിലേക്ക് വലിച്ചെറിയുന്നു
നിങ്ങൾ ഒന്നിന്റെ മധ്യത്തിലായിരിക്കുമ്പോൾ, അപ്‌സ്ട്രീം മാറ്റങ്ങളുണ്ടെന്ന് നിങ്ങൾ മനസ്സിലാക്കുന്നു
നിങ്ങൾ ചെയ്യുന്ന കാര്യങ്ങളിൽ അത് ഒരുപക്ഷേ പ്രസക്തമാണ്. നിങ്ങളുടെ പ്രാദേശിക മാറ്റങ്ങൾ സംഭവിക്കാത്തപ്പോൾ
അപ്‌സ്ട്രീമിലെ മാറ്റങ്ങളുമായി വൈരുദ്ധ്യം, ഒരു ലളിതമായ ജിറ്റ് പുൾ നിങ്ങളെ നീക്കാൻ അനുവദിക്കും
മുന്നോട്ട്.

എന്നിരുന്നാലും, നിങ്ങളുടെ പ്രാദേശിക മാറ്റങ്ങൾ അപ്‌സ്ട്രീമുമായി വൈരുദ്ധ്യമുള്ള സന്ദർഭങ്ങളുണ്ട്
മാറ്റങ്ങൾ, നിങ്ങളുടെ മാറ്റങ്ങൾ തിരുത്തിയെഴുതാൻ git pull വിസമ്മതിക്കുന്നു. അത്തരമൊരു സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് സൂക്ഷിക്കാം
നിങ്ങളുടെ മാറ്റങ്ങൾ ഒഴിവാക്കുക, ഒരു പുൾ ചെയ്യുക, തുടർന്ന് ഇതുപോലെ അൺസ്റ്റാഷ് ചെയ്യുക:

$ ഗിറ്റ് പുൾ
...
ഫയൽ foobar കാലികമല്ല, ലയിപ്പിക്കാൻ കഴിയില്ല.
$ ജിറ്റ് സ്റ്റാഷ്
$ ഗിറ്റ് പുൾ
$ ഗിറ്റ് സ്റ്റാഷ് പോപ്പ്

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

# ... ഹാക്ക് ഹാക്ക് ഹാക്ക് ...
$ git ചെക്ക്ഔട്ട് -b my_wip
$ git commit -a -m "WIP"
$ git ചെക്ക്ഔട്ട് മാസ്റ്റർ
$ തിരുത്തുക അടിയന്തര പരിഹാരം
$ git commit -a -m "തിരക്കിൽ ശരിയാക്കുക"
$ git checkout my_wip
$ git റീസെറ്റ് --സോഫ്റ്റ് ഹെഡ്^
# ... ഹാക്കിംഗ് തുടരുക ...

നിങ്ങൾക്ക് ഉപയോഗിക്കാം ജിറ്റിനെ സ്റ്റാഷ് മുകളിൽ പറഞ്ഞവ ലളിതമാക്കാൻ, ഇതുപോലെ:

# ... ഹാക്ക് ഹാക്ക് ഹാക്ക് ...
$ ജിറ്റ് സ്റ്റാഷ്
$ തിരുത്തുക അടിയന്തര പരിഹാരം
$ git commit -a -m "തിരക്കിൽ ശരിയാക്കുക"
$ ഗിറ്റ് സ്റ്റാഷ് പോപ്പ്
# ... ഹാക്കിംഗ് തുടരുക ...

ഭാഗിക കമ്മിറ്റുകൾ പരിശോധിക്കുന്നു
നിങ്ങൾക്ക് രണ്ടോ അതിലധികമോ കമ്മിറ്റ് ചെയ്യണമെങ്കിൽ git stash save --keep-index ഉപയോഗിക്കാം
വർക്ക് ട്രീയിലെ മാറ്റങ്ങളിൽ, ഓരോ മാറ്റവും വരുത്തുന്നതിന് മുമ്പ് നിങ്ങൾ പരിശോധിക്കണം:

# ... ഹാക്ക് ഹാക്ക് ഹാക്ക് ...
$ git add --patch foo # സൂചികയിൽ ആദ്യ ഭാഗം ചേർക്കുക
$ git stash save --keep-index # മറ്റെല്ലാ മാറ്റങ്ങളും സ്റ്റാഷിൽ സംരക്ഷിക്കുക
$ എഡിറ്റ്/ബിൽഡ്/ടെസ്റ്റ് ആദ്യ ഭാഗം
$ git commit -m 'ആദ്യ ഭാഗം' # പൂർണ്ണമായി പരീക്ഷിച്ച മാറ്റം വരുത്തുക
$ ഗിറ്റ് സ്റ്റാഷ് പോപ്പ് # മറ്റെല്ലാ മാറ്റങ്ങളിലും പ്രവർത്തിക്കാൻ തയ്യാറെടുക്കുക
# ... ഒരു പ്രതിബദ്ധത ശേഷിക്കുന്നതുവരെ മുകളിലുള്ള അഞ്ച് ഘട്ടങ്ങൾ ആവർത്തിക്കുക ...
$ ബാക്കി ഭാഗങ്ങൾ എഡിറ്റ്/ബിൽഡ്/ടെസ്റ്റ്
$ git commit foo -m 'ബാക്കിയുള്ള ഭാഗങ്ങൾ'

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

git fsck --എത്താനാകില്ല |
grep കമ്മിറ്റ് | cut -d\ -f3 |
xargs git log --merges --no-walk --grep=WIP

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