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

പട്ടിക:

NAME

git-push - ബന്ധപ്പെട്ട ഒബ്‌ജക്‌റ്റുകൾക്കൊപ്പം റിമോട്ട് റെഫുകൾ അപ്‌ഡേറ്റ് ചെയ്യുക

സിനോപ്സിസ്

ജിറ്റിനെ തള്ളുക [--എല്ലാം | --കണ്ണാടി | --ടാഗുകൾ] [--follow-tags] [--Atomic] [-n | --dry-run] [--receive-pack= ]
[--റിപ്പോ= ] [-f | --ഫോഴ്സ്] [--പ്രൂൺ] [-വി | --വെർബോസ്]
[-u | --സജ്ജീകരണം]
[--[no-]ഒപ്പിച്ച്|--sign=(ശരി|തെറ്റ്|ചോദിച്ചാൽ)]
[--ഫോഴ്സ് വിത്ത്-ലീസ്[= [: ]]]
[--പരിശോധിക്കുന്നില്ല] [ [ ...]]

വിവരണം

പൂർത്തിയാക്കാൻ ആവശ്യമായ ഒബ്‌ജക്റ്റുകൾ അയയ്‌ക്കുമ്പോൾ, പ്രാദേശിക റെഫറുകൾ ഉപയോഗിച്ച് റിമോട്ട് റെഫുകൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നു
റഫറൻസ് നൽകി.

ഓരോ തവണയും നിങ്ങൾ ഒരു ശേഖരത്തിലേക്ക് തള്ളുമ്പോൾ രസകരമായ കാര്യങ്ങൾ സംഭവിക്കാം
തയ്യാറാക്കുന്നു കൊളുത്തും അവിടെ. അതിനുള്ള ഡോക്യുമെന്റേഷൻ കാണുക git-സ്വീകരിക്കൽ-പാക്ക്(1).

എവിടെയാണ് പുഷ് ചെയ്യേണ്ടതെന്ന് കമാൻഡ് ലൈൻ വ്യക്തമാക്കാത്തപ്പോൾ വാദം,
ബ്രാഞ്ച്.*.നിലവിലെ ബ്രാഞ്ചിനായുള്ള റിമോട്ട് കോൺഫിഗറേഷൻ എവിടെയാണെന്ന് നിർണ്ണയിക്കാൻ ആലോചിക്കുന്നു
തള്ളുക. കോൺഫിഗറേഷൻ നഷ്‌ടപ്പെട്ടാൽ, ഇത് സ്ഥിരസ്ഥിതിയായി മാറുന്നു ഉത്ഭവം.

എന്താണ് പുഷ് ചെയ്യേണ്ടതെന്ന് കമാൻഡ് ലൈൻ വ്യക്തമാക്കാത്തപ്പോൾ ... വാദങ്ങൾ അല്ലെങ്കിൽ --എല്ലാം,
--mirror, --tags ഓപ്ഷനുകൾ, കമാൻഡ് സ്ഥിരസ്ഥിതി കണ്ടെത്തുന്നു കൂടിയാലോചനയിലൂടെ
റിമോട്ട്.*.പുഷ് കോൺഫിഗറേഷൻ, അത് കണ്ടെത്തിയില്ലെങ്കിൽ, push.default കോൺഫിഗറേഷൻ എന്നതിലേക്ക് ബഹുമാനിക്കുന്നു.
എന്ത് തള്ളണമെന്ന് തീരുമാനിക്കുക (കാണുക git-config(1) push.default എന്നതിന്റെ അർത്ഥം).

കമാൻഡ്-ലൈനോ കോൺഫിഗറേഷനോ എന്ത് പുഷ് ചെയ്യണമെന്ന് വ്യക്തമാക്കാത്തപ്പോൾ, ഡിഫോൾട്ട്
പെരുമാറ്റം ഉപയോഗിക്കുന്നു, ഇത് push.default എന്നതിന്റെ ലളിതമായ മൂല്യവുമായി പൊരുത്തപ്പെടുന്നു: കറന്റ്
ബ്രാഞ്ച് അനുബന്ധ അപ്സ്ട്രീം ബ്രാഞ്ചിലേക്ക് തള്ളപ്പെടുന്നു, എന്നാൽ ഒരു സുരക്ഷാ നടപടിയെന്ന നിലയിൽ, പുഷ്
അപ്‌സ്ട്രീം ബ്രാഞ്ചിന് പ്രാദേശിക പേരിന്റെ അതേ പേര് ഇല്ലെങ്കിൽ നിർത്തലാക്കും.

ഓപ്ഷനുകൾ

ഒരു പുഷ് ഓപ്പറേഷന്റെ ലക്ഷ്യസ്ഥാനമായ "റിമോട്ട്" റിപ്പോസിറ്ററി. ഈ പരാമീറ്റർ ആകാം
ഒന്നുകിൽ ഒരു URL (താഴെയുള്ള വിഭാഗം GIT URLs കാണുക) അല്ലെങ്കിൽ ഒരു റിമോട്ടിന്റെ പേര് (വിഭാഗം കാണുക
റിമോട്ടുകൾ താഴെ).

...
ഏത് ഉറവിട ഒബ്‌ജക്‌റ്റ് ഉപയോഗിച്ച് അപ്‌ഡേറ്റ് ചെയ്യേണ്ട ലക്ഷ്യസ്ഥാനം വ്യക്തമാക്കുക. എ യുടെ ഫോർമാറ്റ്
പാരാമീറ്റർ ഒരു ഓപ്ഷണൽ പ്ലസ് + ആണ്, തുടർന്ന് സോഴ്സ് ഒബ്ജക്റ്റ് ,
പിന്നാലെ ഒരു കോളൻ :, തുടർന്ന് ലക്ഷ്യസ്ഥാനം ref .

ദി പലപ്പോഴും നിങ്ങൾ തള്ളാൻ ആഗ്രഹിക്കുന്ന ശാഖയുടെ പേരാണ്, പക്ഷേ അത് ഏതെങ്കിലും ആകാം
മാസ്റ്റർ~1 അല്ലെങ്കിൽ HEAD പോലുള്ള ഏകപക്ഷീയമായ "SHA-4 എക്സ്പ്രഷൻ" (കാണുക gitrevisions(7)).

ദി ഈ പുഷ് ഉപയോഗിച്ച് റിമോട്ട് സൈഡിലെ ഏത് റെഫറാണ് അപ്ഡേറ്റ് ചെയ്തതെന്ന് പറയുന്നു. ഏകപക്ഷീയമായ
പദപ്രയോഗങ്ങൾ ഇവിടെ ഉപയോഗിക്കാൻ കഴിയില്ല, ഒരു യഥാർത്ഥ റഫറൻസ് പേര് നൽകണം. ജിറ്റ് പുഷ് ആണെങ്കിൽ
[ ] ഒന്നുമില്ലാതെ ആർഗ്യുമെന്റ് ചില ref-ൽ അപ്ഡേറ്റ് ചെയ്യാൻ സജ്ജീകരിച്ചിരിക്കുന്നു
ലക്ഷ്യസ്ഥാനം റിമോട്ട് ഉപയോഗിച്ച്. .പുഷ് കോൺഫിഗറേഷൻ വേരിയബിൾ, :
ഭാഗം ഒഴിവാക്കാം-അത്തരമൊരു പുഷ് ഒരു റെഫർ അപ്ഡേറ്റ് ചെയ്യും സാധാരണയായി അപ്ഡേറ്റുകൾ ഇല്ലാതെ
ഏതെങ്കിലും കമാൻഡ് ലൈനിൽ. അല്ലെങ്കിൽ, കാണുന്നില്ല: അതേ അപ്ഡേറ്റ് ചെയ്യുക എന്നാണ് അർത്ഥമാക്കുന്നത്
ref .

പരാമർശിച്ച വസ്തു അപ്ഡേറ്റ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു റിമോട്ടിലെ റഫറൻസ്
വശം. സ്ഥിരസ്ഥിതിയായി, എങ്കിൽ മാത്രമേ ഇത് അനുവദിക്കൂ ഒരു ടാഗ് അല്ല (വിശദീകരണം അല്ലെങ്കിൽ
ഭാരം കുറഞ്ഞത്), തുടർന്ന് വേഗത്തിൽ മുന്നോട്ട് പോകാൻ കഴിയുമെങ്കിൽ മാത്രം . ഓപ്ഷണൽ ഉള്ളതിനാൽ
ലീഡ് +, നിങ്ങൾക്ക് അപ്ഡേറ്റ് ചെയ്യാൻ Git-നോട് പറയാം ഇത് അനുവദിച്ചിട്ടില്ലെങ്കിലും ref
ഡിഫോൾട്ട് (ഉദാ, ഇത് ഫാസ്റ്റ് ഫോർവേഡ് അല്ല.) ഇത് ചെയ്യുന്നു അല്ല ലയിപ്പിക്കാനുള്ള ശ്രമം കടന്നു
. വിശദാംശങ്ങൾക്ക് ചുവടെയുള്ള ഉദാഹരണങ്ങൾ കാണുക.

ടാഗ് refs/tags/ എന്നതിന് സമാനമാണ് അർത്ഥമാക്കുന്നത് :refs/tags/ .

ശൂന്യമായ ഒന്ന് തള്ളുന്നു ഇല്ലാതാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു റിമോട്ട് റിപ്പോസിറ്ററിയിൽ നിന്ന് ref.

പ്രത്യേക refspec : (അല്ലെങ്കിൽ +: നോൺ-ഫാസ്റ്റ് ഫോർവേഡ് അപ്‌ഡേറ്റുകൾ അനുവദിക്കുന്നതിന്) Git-നെ പുഷ് ചെയ്യാൻ നിർദ്ദേശിക്കുന്നു.
"matching" ശാഖകൾ: പ്രാദേശിക വശത്ത്, വിദൂര വശത്ത് നിലനിൽക്കുന്ന എല്ലാ ശാഖകൾക്കും
വിദൂര വശത്ത് അതേ പേരിൽ ഒരു ശാഖ നിലവിലുണ്ടെങ്കിൽ അപ്ഡേറ്റ് ചെയ്യുന്നു.

--എല്ലാം
എല്ലാ ശാഖകളും പുഷ് ചെയ്യുക (അതായത് refs/heads/ എന്നതിന് കീഴിലുള്ള refs); മറ്റുള്ളവരുമായി ഉപയോഗിക്കാൻ കഴിയില്ല .

--പ്രൂൺ
പ്രാദേശിക എതിരാളികളില്ലാത്ത വിദൂര ശാഖകൾ നീക്കം ചെയ്യുക. ഉദാഹരണത്തിന് ഒരു റിമോട്ട്
അതേ പേരിൽ ഒരു പ്രാദേശിക ബ്രാഞ്ച് നിലവിലില്ലെങ്കിൽ ബ്രാഞ്ച് tmp നീക്കം ചെയ്യപ്പെടും
കൂടുതൽ. ഇത് refspecs-നെയും മാനിക്കുന്നു, ഉദാ: git push --prune remote
refs/heads/*:refs/tmp/* എങ്കിൽ റിമോട്ട് refs/tmp/foo നീക്കം ചെയ്യപ്പെടുമെന്ന് ഉറപ്പാക്കും.
refs/heads/foo നിലവിലില്ല.

--കണ്ണാടി
പുഷ് ചെയ്യാൻ ഓരോ റഫറിനും പേരിടുന്നതിനുപകരം, എല്ലാ റഫറൻസുകളും refs/ (ഏത്
റഫറൻസ്/ഹെഡുകൾ/, റഫറൻസ്/റിമോട്ടുകൾ/, റഫറൻസ്/ടാഗുകൾ/) എന്നിവ ഉൾപ്പെടുന്നവയിൽ മാത്രം പരിമിതപ്പെടുത്തിയിട്ടില്ല.
റിമോട്ട് റിപ്പോസിറ്ററിയിലേക്ക്. പുതുതായി സൃഷ്‌ടിച്ച പ്രാദേശിക റെഫറുകൾ റിമോട്ട് എൻഡിലേക്ക് തള്ളപ്പെടും,
പ്രാദേശികമായി അപ്‌ഡേറ്റ് ചെയ്‌ത അവലംബങ്ങൾ റിമോട്ട് എൻഡിൽ നിർബന്ധിതമായി അപ്‌ഡേറ്റ് ചെയ്യപ്പെടും, കൂടാതെ ഇല്ലാതാക്കിയ അവലംബങ്ങൾ ആയിരിക്കും
റിമോട്ട് എൻഡിൽ നിന്ന് നീക്കം ചെയ്തു. കോൺഫിഗറേഷൻ ഓപ്‌ഷനാണെങ്കിൽ ഇത് സ്ഥിരസ്ഥിതിയാണ്
റിമോട്ട്. .കണ്ണാടി സജ്ജമാക്കി.

-n, --ഡ്രൈ-റൺ
യഥാർത്ഥത്തിൽ അപ്ഡേറ്റുകൾ അയയ്ക്കുന്നത് ഒഴികെ എല്ലാം ചെയ്യുക.

--പോർസലൈൻ
മെഷീൻ റീഡബിൾ ഔട്ട്പുട്ട് നിർമ്മിക്കുക. ഓരോ റഫറിനുമുള്ള ഔട്ട്പുട്ട് സ്റ്റാറ്റസ് ലൈൻ ആയിരിക്കും
ടാബ് വേർതിരിച്ച് stderr-ന് പകരം stdout-ലേക്ക് അയച്ചു. യുടെ മുഴുവൻ പ്രതീകാത്മക പേരുകൾ
refs നൽകും.

--ഇല്ലാതാക്കുക
ലിസ്‌റ്റ് ചെയ്‌ത എല്ലാ റഫറൻസുകളും റിമോട്ട് റിപ്പോസിറ്ററിയിൽ നിന്ന് ഇല്ലാതാക്കി. ഇത് പ്രിഫിക്സിംഗ് പോലെയാണ്
എല്ലാം ഒരു വൻകുടലിനൊപ്പം സൂചിപ്പിക്കുന്നു.

--ടാഗുകൾ
റഫറൻസ്/ടാഗുകൾക്ക് കീഴിലുള്ള എല്ലാ റഫറൻസുകളും പ്രസ്‌പഷ്‌മായി ലിസ്‌റ്റ് ചെയ്‌തിരിക്കുന്ന refspecs-ന് പുറമെ
കമാൻഡ് ലൈൻ.

--follow-tags
ഈ ഓപ്‌ഷൻ കൂടാതെ പുഷ് ചെയ്യപ്പെടുന്ന എല്ലാ റെഫറുകളും പുഷ് ചെയ്യുക, കൂടാതെ വ്യാഖ്യാനം പുഷ് ചെയ്യുക
റിമോട്ടിൽ നിന്ന് കാണാത്തതും എന്നാൽ പ്രതിബദ്ധതയിലേക്ക് വിരൽ ചൂണ്ടുന്നതുമായ റെഫുകൾ/ടാഗുകളിലെ ടാഗുകൾ
തള്ളപ്പെടുന്ന റെഫറുകളിൽ നിന്ന് എത്തിച്ചേരാനാകും. ഇതും കൂടെ വ്യക്തമാക്കാം
കോൺഫിഗറേഷൻ വേരിയബിൾ push.followTags. കൂടുതൽ വിവരങ്ങൾക്ക്, കാണുക push.followTags in
git-config(1).

--[no-]ഒപ്പ്, --sign=(ശരി|തെറ്റ്|ചോദിച്ചാൽ)
സ്വീകരിക്കുന്ന ഭാഗത്ത് റെഫറുകൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനായി പുഷ് അഭ്യർത്ഥനയിൽ GPG ഒപ്പിടുക, അത് അനുവദിക്കുക
കൊളുത്തുകൾ പരിശോധിച്ച് കൂടാതെ/അല്ലെങ്കിൽ ലോഗിൻ ചെയ്യപ്പെടും. തെറ്റോ --ഒപ്പിട്ടില്ലെങ്കിലോ, ഒരു ഒപ്പും ഉണ്ടാകില്ല
ശ്രമിച്ചു. true അല്ലെങ്കിൽ --signed ആണെങ്കിൽ, സെർവർ പിന്തുണയ്ക്കുന്നില്ലെങ്കിൽ പുഷ് പരാജയപ്പെടും
ഒപ്പിട്ട തള്ളലുകൾ. ചോദിച്ചാൽ എന്ന് സജ്ജീകരിച്ചാൽ, സൈൻ ചെയ്തതായി സെർവർ പിന്തുണയ്ക്കുന്നുവെങ്കിൽ മാത്രം സൈൻ ചെയ്യുക
തള്ളുന്നു. gpg --sign-ലേക്കുള്ള യഥാർത്ഥ കോൾ പരാജയപ്പെടുകയാണെങ്കിൽ പുഷ് പരാജയപ്പെടും. കാണുക git-
സ്വീകരിക്കുക-പാക്ക്(1) സ്വീകരിക്കുന്ന അവസാനത്തെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക്.

--[no-]ആറ്റം
ലഭ്യമാണെങ്കിൽ റിമോട്ട് സൈഡിൽ ഒരു ആറ്റോമിക് ഇടപാട് ഉപയോഗിക്കുക. ഒന്നുകിൽ എല്ലാ റഫറൻസുകളും
അപ്‌ഡേറ്റ് ചെയ്‌തു, അല്ലെങ്കിൽ പിശകുണ്ടായാൽ, റെഫറുകളൊന്നും അപ്‌ഡേറ്റ് ചെയ്യപ്പെടുന്നില്ല. സെർവർ ആറ്റോമിക് പിന്തുണയ്ക്കുന്നില്ലെങ്കിൽ
തള്ളുന്നു തള്ളൽ പരാജയപ്പെടും.

--receive-pack= , --exec=
എന്നതിലേക്കുള്ള പാത git-സ്വീകരിക്കൽ-പാക്ക് വിദൂര അറ്റത്തുള്ള പ്രോഗ്രാം. തള്ളുമ്പോൾ ചിലപ്പോൾ ഉപയോഗപ്രദമാകും
ssh-ൽ ഉള്ള ഒരു റിമോട്ട് റിപ്പോസിറ്ററിയിലേക്ക്, കൂടാതെ നിങ്ങൾക്ക് ഒരു ഡയറക്‌ടറിയിൽ പ്രോഗ്രാം ഇല്ല
സ്ഥിരസ്ഥിതി $PATH.

--[no-]force-with-lease, --force-with-lease= ,
--force-with-lease= :
സാധാരണഗതിയിൽ, "ജിറ്റ് പുഷ്" ഒരു റിമോട്ട് റെഫർ അപ്ഡേറ്റ് ചെയ്യാൻ വിസമ്മതിക്കുന്നു, അത് പൂർവ്വികൻ അല്ല.
ഇത് തിരുത്തിയെഴുതാൻ ലോക്കൽ റെഫർ ഉപയോഗിക്കുന്നു.

റിമോട്ട് റെഫറിന്റെ നിലവിലെ മൂല്യം ആണെങ്കിൽ ഈ ഓപ്‌ഷൻ ഈ നിയന്ത്രണത്തെ അസാധുവാക്കുന്നു
പ്രതീക്ഷിച്ച മൂല്യം. അല്ലാത്തപക്ഷം "git push" പരാജയപ്പെടുന്നു.

നിങ്ങൾ ഇതിനകം പ്രസിദ്ധീകരിച്ചവ പുനഃസ്ഥാപിക്കണമെന്ന് സങ്കൽപ്പിക്കുക. നിങ്ങൾ ചെയ്യേണ്ടി വരും
നിങ്ങൾ യഥാർത്ഥത്തിൽ ചരിത്രം മാറ്റിസ്ഥാപിക്കുന്നതിന് "വേഗതയിൽ മുന്നോട്ട് പോകേണ്ടതുണ്ട്" എന്ന നിയമം മറികടക്കുക
റീബേസ്ഡ് ഹിസ്റ്ററി സഹിതം പ്രസിദ്ധീകരിച്ചു. നിങ്ങളുടെ ഒറിജിനലിന് മുകളിൽ മറ്റാരെങ്കിലും നിർമ്മിച്ചിട്ടുണ്ടെങ്കിൽ
നിങ്ങൾ ചരിത്രം പുനഃസ്ഥാപിക്കുമ്പോൾ, റിമോട്ടിലെ ശാഖയുടെ അറ്റം മുന്നോട്ട് പോയേക്കാം
അവളുടെ പ്രതിബദ്ധത, അന്ധമായി --ബലം കൊണ്ട് തള്ളുന്നത് അവളുടെ ജോലി നഷ്ടപ്പെടും.

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

--ഫോഴ്സ് വിത്ത്-ലീസ് മാത്രം, വിശദാംശങ്ങൾ വ്യക്തമാക്കാതെ, എല്ലാ വിദൂര റഫറൻസുകളും സംരക്ഷിക്കും
അവയുടെ നിലവിലെ മൂല്യം പോലെ തന്നെ ആയിരിക്കണമെന്ന് ആവശ്യപ്പെട്ട് അപ്‌ഡേറ്റ് ചെയ്യാൻ പോകുന്നവ
റിമോട്ട് ട്രാക്കിംഗ് ബ്രാഞ്ച് ഞങ്ങൾക്കുണ്ട്.

--force-with-lease= , പ്രതീക്ഷിക്കുന്ന മൂല്യം വ്യക്തമാക്കാതെ, സംരക്ഷിക്കും
ref (ഒറ്റയ്ക്ക്), അത് അപ്‌ഡേറ്റ് ചെയ്യാൻ പോകുകയാണെങ്കിൽ, അതിന്റെ നിലവിലെ മൂല്യം ആവശ്യപ്പെടുന്നതിലൂടെ
അതിനുള്ള റിമോട്ട് ട്രാക്കിംഗ് ബ്രാഞ്ചിന് സമാനമാണ്.

--force-with-lease= : പേരുള്ള ref (ഒറ്റയ്ക്ക്), അങ്ങനെയാണെങ്കിൽ അത് സംരക്ഷിക്കും
അപ്‌ഡേറ്റ് ചെയ്യാൻ പോകുന്നു, അതിന്റെ നിലവിലെ മൂല്യം വ്യക്തമാക്കിയതിന് തുല്യമായിരിക്കണമെന്ന് ആവശ്യപ്പെടുന്നു
മൂല്യം (ഇത് ഞങ്ങൾ വിദൂര-ട്രാക്കിംഗ് ബ്രാഞ്ചിൽ നിന്ന് വ്യത്യസ്തമായി അനുവദിക്കും
പുനർനാമകരണം ചെയ്യുക, അല്ലെങ്കിൽ ഞങ്ങൾക്ക് അത്തരമൊരു റിമോട്ട് ട്രാക്കിംഗ് ബ്രാഞ്ച് പോലും ഉണ്ടാകേണ്ടതില്ല
ഈ ഫോം ഉപയോഗിക്കുമ്പോൾ).

--force-with-lease= ഒഴികെയുള്ള എല്ലാ ഫോമുകളും ശ്രദ്ധിക്കുക : എന്ന് വ്യക്തമാക്കുന്നു
റഫറിന്റെ പ്രതീക്ഷിക്കുന്ന നിലവിലെ മൂല്യം ഇപ്പോഴും പരീക്ഷണാത്മകമാണ്
ഈ സവിശേഷത ഉപയോഗിച്ച് അനുഭവം നേടുമ്പോൾ അർത്ഥശാസ്ത്രം മാറിയേക്കാം.

"--no-force-with-lease" കമാൻഡിൽ മുമ്പത്തെ എല്ലാ --force-with-lease-ഉം റദ്ദാക്കും.
ലൈൻ.

-f, --ഫോഴ്സ്
സാധാരണഗതിയിൽ, ഒരു പൂർവ്വികൻ അല്ലാത്ത ഒരു റിമോട്ട് റെഫർ അപ്ഡേറ്റ് ചെയ്യാൻ കമാൻഡ് വിസമ്മതിക്കുന്നു
ഇത് തിരുത്തിയെഴുതാൻ ലോക്കൽ റെഫർ ഉപയോഗിക്കുന്നു. കൂടാതെ, --force-with-lease ഓപ്ഷൻ ഉപയോഗിക്കുമ്പോൾ, the
നിലവിലെ മൂല്യവുമായി പൊരുത്തപ്പെടാത്ത റിമോട്ട് റെഫർ അപ്ഡേറ്റ് ചെയ്യാൻ കമാൻഡ് വിസമ്മതിക്കുന്നു
പ്രതീക്ഷിച്ചത്.

ഈ ഫ്ലാഗ് ഈ ചെക്കുകൾ പ്രവർത്തനരഹിതമാക്കുന്നു, കൂടാതെ റിമോട്ട് റിപ്പോസിറ്ററി കമ്മിറ്റുകൾ നഷ്‌ടപ്പെടാൻ ഇടയാക്കും;
അത് ശ്രദ്ധയോടെ ഉപയോഗിക്കുക.

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

--repo=
ഈ ഓപ്ഷൻ തുല്യമാണ് വാദം. രണ്ടും വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, ദി
കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റിന് മുൻഗണനയുണ്ട്.

-u, --set-upstream
കാലികമായതോ വിജയകരമായി പുഷ് ചെയ്തതോ ആയ എല്ലാ ബ്രാഞ്ചുകൾക്കും അപ്‌സ്ട്രീം ചേർക്കുക (ട്രാക്കിംഗ്)
റഫറൻസ്, ആർഗ്യുമെന്റ്-ലെസ്സ് ഉപയോഗിച്ചു git-pull(1) മറ്റ് കമാൻഡുകൾ. കൂടുതൽ വിവരങ്ങൾക്ക്,
കാണുക ശാഖ. .ലയിപ്പിക്കുക in git-config(1).

--[no-]നേർത്ത
ഈ ഓപ്ഷനുകൾ കൈമാറുന്നു git-send-പാക്ക്(1). ഒരു നേർത്ത കൈമാറ്റം ഗണ്യമായി കുറയ്ക്കുന്നു
അയച്ചയാളും സ്വീകർത്താവും ഒരേ ഒബ്ജക്റ്റുകളിൽ പലതും പങ്കിടുമ്പോൾ അയച്ച ഡാറ്റയുടെ അളവ്
സാധാരണ. ഡിഫോൾട്ട് --നേർത്തതാണ്.

-q, --നിശബ്ദത
ഒരു പിശക് സംഭവിക്കുന്നില്ലെങ്കിൽ, അപ്‌ഡേറ്റ് ചെയ്‌ത റെഫറുകളുടെ ലിസ്റ്റിംഗ് ഉൾപ്പെടെ എല്ലാ ഔട്ട്‌പുട്ടും അടിച്ചമർത്തുക.
സ്റ്റാൻഡേർഡ് പിശക് സ്ട്രീമിലേക്ക് പുരോഗതി റിപ്പോർട്ട് ചെയ്തിട്ടില്ല.

-v, --വെർബോസ്
വാചാലമായി ഓടുക.

--പുരോഗതി
സ്റ്റാൻഡേർഡ് എറർ സ്ട്രീമിൽ സ്ഥിരസ്ഥിതിയായി പ്രോഗ്രസ് സ്റ്റാറ്റസ് റിപ്പോർട്ട് ചെയ്യപ്പെടുന്നു
-q വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, ഒരു ടെർമിനലിൽ ഘടിപ്പിച്ചിരിക്കുന്നു. ഈ പതാക പുരോഗതി നിലയെ പോലും പ്രേരിപ്പിക്കുന്നു
സാധാരണ പിശക് സ്ട്രീം ഒരു ടെർമിനലിലേക്ക് നയിക്കപ്പെടുന്നില്ലെങ്കിൽ.

--no-recurse-submodules, --recurse-submodules=ചെക്ക്|ഓൺ-ഡിമാൻഡ്|ഇല്ല
പുഷ് ചെയ്യേണ്ട പുനരവലോകനങ്ങൾ ഉപയോഗിക്കുന്ന എല്ലാ സബ്‌മോഡ്യൂൾ കമ്മിറ്റുകളും ഉണ്ടെന്ന് ഉറപ്പാക്കാൻ ഇത് ഉപയോഗിച്ചേക്കാം
ഒരു റിമോട്ട് ട്രാക്കിംഗ് ബ്രാഞ്ചിൽ ലഭ്യമാണ്. എങ്കിൽ ചെക്ക് ഉപയോഗിക്കുന്നത് Git എല്ലാം പരിശോധിക്കും
പുഷ് ചെയ്യേണ്ട പുനരവലോകനങ്ങളിൽ മാറ്റം വരുത്തിയ സബ്മോഡ്യൂൾ കമ്മിറ്റുകൾ കുറഞ്ഞത് ലഭ്യമാണ്
സബ്മോഡ്യൂളിന്റെ ഒരു റിമോട്ട്. ഏതെങ്കിലും പ്രതിബദ്ധത നഷ്ടമായാൽ, തള്ളൽ നിർത്തലാക്കും
പൂജ്യമല്ലാത്ത അവസ്ഥയിൽ പുറത്തുകടക്കുക. എങ്കിൽ ആവശ്യപ്പെടുന്നതനുസരിച്ച് എന്നതിൽ മാറിയ എല്ലാ ഉപഘടകങ്ങളും ഉപയോഗിക്കുന്നു
തള്ളേണ്ട തിരുത്തലുകൾ തള്ളപ്പെടും. ഓൺ-ഡിമാൻഡ് ആവശ്യമായ എല്ലാം തള്ളാൻ കഴിഞ്ഞില്ല എങ്കിൽ
പുനരവലോകനങ്ങൾ അത് നിർത്തലാക്കുകയും പൂജ്യമല്ലാത്ത പദവിയോടെ പുറത്തുകടക്കുകയും ചെയ്യും. ഒരു മൂല്യം ഇല്ല or
ഉപയോഗിച്ച് --no-recurse-submodules push.recurseSubmodules അസാധുവാക്കാൻ ഉപയോഗിക്കാം
സബ്‌മോഡ്യൂൾ റിക്കർഷൻ ആവശ്യമില്ലാത്തപ്പോൾ കോൺഫിഗറേഷൻ വേരിയബിൾ.

--[ഇല്ല-]സ്ഥിരീകരിക്കുക
പ്രീ-പുഷ് ഹുക്ക് ടോഗിൾ ചെയ്യുക (കാണുക githooks(5)). സ്ഥിരസ്ഥിതി --പരിശോധിക്കുക, ഹുക്ക് എ നൽകുന്നു
തള്ളൽ തടയാനുള്ള അവസരം. --no-verify ഉപയോഗിച്ച്, ഹുക്ക് പൂർണ്ണമായും ബൈപാസ് ചെയ്യുന്നു.

GIT URL-കൾ

പൊതുവേ, URL-കളിൽ ട്രാൻസ്പോർട്ട് പ്രോട്ടോക്കോൾ, വിലാസം എന്നിവയെക്കുറിച്ചുള്ള വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു
റിമോട്ട് സെർവറും റിപ്പോസിറ്ററിയിലേക്കുള്ള പാതയും. ഗതാഗത പ്രോട്ടോക്കോൾ അനുസരിച്ച്, ചിലത്
ഈ വിവരങ്ങളുടെ അഭാവം ഉണ്ടാകാം.

Git ssh, git, http, https പ്രോട്ടോക്കോളുകൾ പിന്തുണയ്ക്കുന്നു (കൂടാതെ, ftp, ftps എന്നിവയും ഉപയോഗിക്കാം
എടുക്കുന്നതിനും തള്ളുന്നതിനും rsync ഉപയോഗിക്കാം, എന്നാൽ ഇവ കാര്യക്ഷമമല്ലാത്തതും
ഒഴിവാക്കി; അവ ഉപയോഗിക്കരുത്).

നേറ്റീവ് ട്രാൻസ്പോർട്ട് (അതായത് git:// URL) ആധികാരികത നൽകുന്നില്ല, ഒപ്പം ഉപയോഗിക്കുകയും വേണം
സുരക്ഷിതമല്ലാത്ത നെറ്റ്‌വർക്കുകളിൽ ജാഗ്രത.

അവയ്‌ക്കൊപ്പം ഇനിപ്പറയുന്ന വാക്യഘടനകൾ ഉപയോഗിക്കാം:

· ssh://[user@]host.xz[:port]/path/to/repo.git/

git://host.xz[:port]/path/to/repo.git/

· http[s]://host.xz[:port]/path/to/repo.git/

· ftp[s]://host.xz[:port]/path/to/repo.git/

· rsync://host.xz/path/to/repo.git/

ssh പ്രോട്ടോക്കോളിനൊപ്പം ഒരു ഇതര scp പോലുള്ള വാക്യഘടനയും ഉപയോഗിക്കാം:

· [user@]host.xz:path/to/repo.git/

ആദ്യത്തെ കോളണിന് മുമ്പ് സ്ലാഷുകൾ ഇല്ലെങ്കിൽ മാത്രമേ ഈ വാക്യഘടന തിരിച്ചറിയൂ. ഇത് സഹായിക്കുന്നു
ഒരു കോളൻ അടങ്ങുന്ന ഒരു പ്രാദേശിക പാതയെ വേർതിരിക്കുക. ഉദാഹരണത്തിന് ലോക്കൽ പാത്ത് foo:bar can
ഒരു ssh url ആയി ദുർവ്യാഖ്യാനം ചെയ്യപ്പെടാതിരിക്കാൻ ഒരു സമ്പൂർണ്ണ പാത അല്ലെങ്കിൽ ./foo:bar എന്ന് വ്യക്തമാക്കുക.

ssh, git പ്രോട്ടോക്കോളുകൾ ~ഉപയോക്തൃനാമ വിപുലീകരണത്തെ പിന്തുണയ്ക്കുന്നു:

· ssh://[user@]host.xz[:port]/~[user]/path/to/repo.git/

git://host.xz[:port]/~[user]/path/to/repo.git/

· [user@]host.xz:/~[user]/path/to/repo.git/

പ്രാദേശിക റിപ്പോസിറ്ററികൾക്കായി, Git നേറ്റീവ് ആയി പിന്തുണയ്ക്കുന്നു, ഇനിപ്പറയുന്ന വാക്യഘടനകൾ ആയിരിക്കാം
ഉപയോഗിച്ചവ:

· /path/to/repo.git/

· ഫയൽ:///path/to/repo.git/

ഈ രണ്ട് വാക്യഘടനകളും മിക്കവാറും തുല്യമാണ്, ക്ലോണിംഗ് ചെയ്യുമ്പോൾ ഒഴികെ, ആദ്യത്തേത് സൂചിപ്പിക്കുമ്പോൾ
--ലോക്കൽ ഓപ്ഷൻ. കാണുക git-ക്ലോൺ(1) വിശദാംശങ്ങൾക്ക്.

ഒരു നിശ്ചിത ട്രാൻസ്പോർട്ട് പ്രോട്ടോക്കോൾ എങ്ങനെ കൈകാര്യം ചെയ്യണമെന്ന് Git-ന് അറിയാത്തപ്പോൾ, അത് ഉപയോഗിക്കാൻ ശ്രമിക്കുന്നു
റിമോട്ട്- വിദൂര സഹായി, ഒരാൾ നിലവിലുണ്ടെങ്കിൽ. ഒരു റിമോട്ട് സഹായിയെ വ്യക്തമായി അഭ്യർത്ഥിക്കാൻ,
ഇനിപ്പറയുന്ന വാക്യഘടന ഉപയോഗിക്കാം:

· ::

എവിടെ ഒരു പാത്ത്, സെർവറും പാതയും അല്ലെങ്കിൽ ഒരു അനിയന്ത്രിതമായ URL പോലുള്ള സ്ട്രിംഗ് ആകാം
പ്രത്യേക വിദൂര സഹായി അഭ്യർത്ഥിച്ചാൽ തിരിച്ചറിഞ്ഞു. കാണുക gitremote-സഹായികൾ(1) വേണ്ടി
വിശദാംശങ്ങൾ.

സമാനമായ പേരുള്ള റിമോട്ട് റിപ്പോസിറ്ററികൾ ഒരു വലിയ സംഖ്യ ഉണ്ടെങ്കിൽ, നിങ്ങൾ എ
അവയ്‌ക്കായി വ്യത്യസ്ത ഫോർമാറ്റ് (നിങ്ങൾ ഉപയോഗിക്കുന്ന URL-കൾ URL-കളിലേക്ക് മാറ്റിയെഴുതപ്പെടും
ജോലി), നിങ്ങൾക്ക് ഫോമിന്റെ ഒരു കോൺഫിഗറേഷൻ വിഭാഗം സൃഷ്ടിക്കാൻ കഴിയും:

[url" "]
പകരം =

ഉദാഹരണത്തിന്, ഇതിനൊപ്പം:

[url "git://git.host.xz/"]
പകരംOf = host.xz:/path/to/
പകരം = ജോലി:

"work:repo.git" പോലെയുള്ള ഒരു URL അല്ലെങ്കിൽ "host.xz:/path/to/repo.git" പോലെയുള്ള ഒരു URL ഏതെങ്കിലും ഒന്നിൽ മാറ്റിയെഴുതും
ഒരു URL "git://git.host.xz/repo.git" ആയി എടുക്കുന്ന സന്ദർഭം.

പുഷിനായി മാത്രം URL-കൾ മാറ്റിയെഴുതാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾക്ക് ഒരു കോൺഫിഗറേഷൻ വിഭാഗം സൃഷ്ടിക്കാൻ കഴിയും
ഫോം:

[url" "]
പുഷ് പകരം =

ഉദാഹരണത്തിന്, ഇതിനൊപ്പം:

[url "ssh://example.org/"]
പുഷ് പകരം = git://example.org/

"git://example.org/path/to/repo.git" പോലെയുള്ള ഒരു URL വീണ്ടും എഴുതപ്പെടും
പുഷുകൾക്കായി "ssh://example.org/path/to/repo.git", എന്നാൽ പുൾ ചെയ്യുന്നത് അപ്പോഴും യഥാർത്ഥമായത് ഉപയോഗിക്കും.
URL

റിമോട്ടുകൾ

URL എന്നതിന് പകരം ഇനിപ്പറയുന്നതിൽ ഒന്നിന്റെ പേര് ഉപയോഗിക്കാം വാദം:

Git കോൺഫിഗറേഷൻ ഫയലിലെ ഒരു റിമോട്ട്: $GIT_DIR/config,

$GIT_DIR/റിമോട്ട് ഡയറക്‌ടറിയിലെ ഒരു ഫയൽ, അല്ലെങ്കിൽ

$GIT_DIR/ശാഖ ഡയറക്ടറിയിലെ ഒരു ഫയൽ.

കമാൻഡ് ലൈനിൽ നിന്ന് refspec ഒഴിവാക്കാൻ ഇവയെല്ലാം നിങ്ങളെ അനുവദിക്കുന്നു കാരണം അവ ഓരോന്നും
സ്ഥിരസ്ഥിതിയായി git ഉപയോഗിക്കുന്ന ഒരു refspec അടങ്ങിയിരിക്കുന്നു.

എന്ന വിദൂര in കോൺഫിഗറേഷൻ ഫയല്
നിങ്ങൾ മുമ്പ് കോൺഫിഗർ ചെയ്‌ത ഒരു റിമോട്ടിന്റെ പേര് നൽകാൻ നിങ്ങൾക്ക് തിരഞ്ഞെടുക്കാം
git-റിമോട്ട്(1), git-config(1) അല്ലെങ്കിൽ $GIT_DIR/config ഫയലിൽ ഒരു മാനുവൽ എഡിറ്റ് വഴിയും. URL
ഈ റിമോട്ടിന്റെ റിപ്പോസിറ്ററി ആക്സസ് ചെയ്യാൻ ഉപയോഗിക്കും. ഈ റിമോട്ടിന്റെ റെഫ്സ്പെക് ആയിരിക്കും
നിങ്ങൾ കമാൻഡ് ലൈനിൽ ഒരു refspec നൽകാത്തപ്പോൾ സ്ഥിരസ്ഥിതിയായി ഉപയോഗിക്കുന്നു. എന്നതിലെ പ്രവേശനം
config ഫയൽ ഇതുപോലെ ദൃശ്യമാകും:

[റിമോട്ട്" "]
url =
pushurl =
തള്ളുക =
കൊണ്ടുവരിക =

ദി തള്ളലുകൾക്ക് മാത്രം ഉപയോഗിക്കുന്നു. ഇത് ഓപ്ഷണലും ഡിഫോൾട്ടുമാണ് .

എന്ന ഫയല് in $GIT_DIR/റിമോട്ടുകൾ
$GIT_DIR/remotes-ൽ ഒരു ഫയലിന്റെ പേര് നൽകാൻ നിങ്ങൾക്ക് തിരഞ്ഞെടുക്കാം. ഈ ഫയലിലെ URL
റിപ്പോസിറ്ററി ആക്സസ് ചെയ്യാൻ ഉപയോഗിക്കും. ഈ ഫയലിലെ refspec സ്ഥിരസ്ഥിതിയായി ഉപയോഗിക്കും
നിങ്ങൾ കമാൻഡ് ലൈനിൽ ഒരു refspec നൽകാത്തപ്പോൾ. ഈ ഫയലിൽ ഇനിപ്പറയുന്നവ ഉണ്ടായിരിക്കണം
ഫോർമാറ്റ്:

URL: മുകളിലുള്ള URL ഫോർമാറ്റുകളിൽ ഒന്ന്
തള്ളുക:
വലിക്കുക:

പുഷ്: ലൈനുകൾ ഉപയോഗിക്കുന്നത് ജിറ്റിനെ തള്ളുക ഒപ്പം പുൾ: ലൈനുകൾ ഉപയോഗിക്കുന്നത് ജിറ്റിനെ വലിക്കുക ഒപ്പം ജിറ്റിനെ കൊണ്ടുവരിക.
അധിക ബ്രാഞ്ച് മാപ്പിംഗുകൾക്കായി ഒന്നിലധികം പുഷ്: ഒപ്പം വലിക്കുക: ലൈനുകൾ വ്യക്തമാക്കിയേക്കാം.

എന്ന ഫയല് in $GIT_DIR/ശാഖകൾ
$GIT_DIR/ശാഖകളിൽ ഒരു ഫയലിന്റെ പേര് നൽകാൻ നിങ്ങൾക്ക് തിരഞ്ഞെടുക്കാം. ഈ ഫയലിലെ URL
റിപ്പോസിറ്ററി ആക്സസ് ചെയ്യാൻ ഉപയോഗിക്കും. ഈ ഫയലിന് ഇനിപ്പറയുന്ന ഫോർമാറ്റ് ഉണ്ടായിരിക്കണം:

#

ആവശ്യമാണ്; # ഓപ്ഷണൽ ആണ്.

പ്രവർത്തനത്തെ ആശ്രയിച്ച്, നിങ്ങൾ ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, git ഇനിപ്പറയുന്ന റെഫ്‌സ്പെക്‌സുകളിലൊന്ന് ഉപയോഗിക്കും
കമാൻഡ് ലൈനിൽ ഒരെണ്ണം നൽകുക. $GIT_DIR/ശാഖകളിലെ ഈ ഫയലിന്റെ പേരാണ്
ഒപ്പം മാസ്റ്റർ ചെയ്യാൻ ഡിഫോൾട്ടുകൾ.

git fetch ഉപയോഗിക്കുന്നു:

റഫറൻസ്/ഹെഡുകൾ/ :refs/heads/

git പുഷ് ഉപയോഗിക്കുന്നു:

തല:റഫറൻസ്/ഹെഡുകൾ/

ഔട്ട്പ്

"ജിറ്റ് പുഷ്" ന്റെ ഔട്ട്പുട്ട് ഉപയോഗിക്കുന്ന ഗതാഗത രീതിയെ ആശ്രയിച്ചിരിക്കുന്നു; ഈ ഭാഗം വിവരിക്കുന്നു
Git പ്രോട്ടോക്കോൾ (പ്രാദേശികമായോ ssh വഴിയോ) അമർത്തുമ്പോൾ ഔട്ട്പുട്ട്.

പുഷ് സ്റ്റാറ്റസ് ടാബ്ലർ രൂപത്തിൽ ഔട്ട്പുട്ട് ചെയ്യുന്നു, ഓരോ വരിയും സ്റ്റാറ്റസിനെ പ്രതിനിധീകരിക്കുന്നു
ഒരൊറ്റ റഫറിന്റെ. ഓരോ വരിയും രൂപത്തിലാണ്:

-> ( )

--porcelain ആണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, ഔട്ട്‌പുട്ടിന്റെ ഓരോ വരിയും ഇനിപ്പറയുന്ന രൂപത്തിലാണ്:

\t : \t ( )

--porcelain അല്ലെങ്കിൽ --verbose ഓപ്‌ഷൻ ഉപയോഗിച്ചാൽ മാത്രമേ അപ്-ടു-ഡേറ്റ് റെഫറുകളുടെ നില കാണിക്കൂ.

പതാക
റഫറിന്റെ നില സൂചിപ്പിക്കുന്ന ഒരൊറ്റ പ്രതീകം:

(സ്ഥലം)
വിജയകരമായി മുന്നോട്ട് തള്ളിയതിന്;

+
വിജയകരമായ നിർബന്ധിത അപ്‌ഡേറ്റിനായി;

-
വിജയകരമായി ഇല്ലാതാക്കിയ ഒരു റഫറിനായി;

*
വിജയകരമായി പുഷ് ചെയ്ത പുതിയ റഫറിനായി;

!
നിരസിക്കപ്പെട്ടതോ തള്ളുന്നതിൽ പരാജയപ്പെട്ടതോ ആയ ഒരു റഫറിനായി; ഒപ്പം

=
കാലികമായതും തള്ളേണ്ട ആവശ്യമില്ലാത്തതുമായ ഒരു റെഫറിനായി.

സംഗ്രഹം
വിജയകരമായി പുഷ് ചെയ്‌ത ഒരു റഫറിനായി, സംഗ്രഹം റഫറിന്റെ പഴയതും പുതിയതുമായ മൂല്യങ്ങൾ കാണിക്കുന്നു
ജിറ്റ് ലോഗ് ഒരു ആർഗ്യുമെന്റായി ഉപയോഗിക്കുന്നതിന് അനുയോജ്യമായ ഒരു ഫോം (ഇത് .. മിക്കയിടത്തും
കേസുകൾ, കൂടാതെ ... നിർബന്ധിത നോൺ-ഫാസ്റ്റ്-ഫോർവേഡ് അപ്‌ഡേറ്റുകൾക്കായി).

പരാജയപ്പെട്ട അപ്‌ഡേറ്റിന്, കൂടുതൽ വിശദാംശങ്ങൾ നൽകിയിരിക്കുന്നു:

നിരസിച്ചു
ഒരു ഫാസ്റ്റ് ഫോർവേഡ് അല്ലാത്തതിനാൽ, റഫർ അയക്കാൻ Git ഒരിക്കലും ശ്രമിച്ചില്ല
നിങ്ങൾ അപ്ഡേറ്റ് നിർബന്ധിച്ചില്ല.

റിമോട്ട് നിരസിച്ചു
റിമോട്ട് എൻഡ് അപ്‌ഡേറ്റ് നിരസിച്ചു. സാധാരണയായി റിമോട്ട് സൈഡിൽ ഒരു കൊളുത്ത് മൂലമാണ് സംഭവിക്കുന്നത്, അല്ലെങ്കിൽ
കാരണം റിമോട്ട് റിപ്പോസിറ്ററിക്ക് ഇനിപ്പറയുന്ന സുരക്ഷാ ഓപ്ഷനുകളിലൊന്ന് പ്രാബല്യത്തിൽ ഉണ്ട്:
receive.denyCurrentBranch (ചെക്ക് ഔട്ട് ചെയ്‌ത ബ്രാഞ്ചിലേക്കുള്ള പുഷ്‌കൾക്ക്),
receive.denyNonFastForwards (നിർബന്ധിത നോൺ-ഫാസ്റ്റ് ഫോർവേഡ് അപ്‌ഡേറ്റുകൾക്ക്),
receive.denyDeletes അല്ലെങ്കിൽ receive.denyDeleteCurrent. കാണുക git-config(1).

വിദൂര പരാജയം
റിമോട്ട് എൻഡ് റെഫറിന്റെ വിജയകരമായ അപ്‌ഡേറ്റ് റിപ്പോർട്ട് ചെയ്തില്ല, ഒരുപക്ഷേ കാരണം
വിദൂര വശത്ത് ഒരു താൽക്കാലിക പിശക്, നെറ്റ്‌വർക്ക് കണക്ഷനിൽ ഒരു ഇടവേള അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും
ക്ഷണികമായ പിശക്.

നിന്ന്
പുഷ് ചെയ്യപ്പെടുന്ന പ്രാദേശിക റെഫറിന്റെ പേര്, അതിന്റെ റഫറൻസ് മൈനസ്/ / ഉപസർഗ്ഗം. ഈ സന്ദർഭത്തിൽ
ഇല്ലാതാക്കൽ, പ്രാദേശിക റെഫറിന്റെ പേര് ഒഴിവാക്കിയിരിക്കുന്നു.

ലേക്ക്
അപ്‌ഡേറ്റ് ചെയ്യുന്ന റിമോട്ട് റെഫറിന്റെ പേര്, അതിന്റെ റഫറൻസ് മൈനസ്/ / ഉപസർഗ്ഗം.

കാരണം
മനുഷ്യർക്ക് വായിക്കാവുന്ന ഒരു വിശദീകരണം. വിജയകരമായി പുഷ് ചെയ്ത റഫറുകളുടെ കാര്യത്തിൽ, വിശദീകരണമില്ല
ആവശ്യമാണ്. പരാജയപ്പെട്ട ഒരു റെഫറിനായി, പരാജയത്തിന്റെ കാരണം വിവരിച്ചിരിക്കുന്നു.

കുറിപ്പ് ആമുഖം ഫാസ്റ്റ്-ഫോർവേഡ്സ്

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

A മുതൽ B വരെയുള്ള ഫാസ്റ്റ് ഫോർവേഡ് അപ്‌ഡേറ്റിൽ, യഥാർത്ഥ കമ്മിറ്റ് എ നിർമ്മിച്ച കമ്മിറ്റുകളുടെ സെറ്റ്
മുകളിൽ പുതിയ കമ്മിറ്റ് ബി നിർമ്മിക്കുന്ന കമ്മിറ്റുകളുടെ ഒരു ഉപവിഭാഗമാണ്. അതിനാൽ, അത് ചെയ്യുന്നില്ല
ഏതെങ്കിലും ചരിത്രം നഷ്ടപ്പെടുത്തുക.

വിപരീതമായി, നോൺ-ഫാസ്റ്റ്-ഫോർവേഡ് അപ്‌ഡേറ്റിന് ചരിത്രം നഷ്‌ടമാകും. ഉദാഹരണത്തിന്, നിങ്ങൾ ഒപ്പം എന്ന് കരുതുക
മറ്റൊരാൾ അതേ കമ്മിറ്റ് എക്‌സിൽ ആരംഭിച്ചു, നിങ്ങൾ ബി കമ്മിറ്റ് ചെയ്യുന്ന ഒരു ചരിത്രം നിർമ്മിച്ചു
മറ്റൊരാൾ ഒരു ചരിത്രം നിർമ്മിക്കുമ്പോൾ, A.

B
/
---X---എ

മറ്റൊരാൾ ഇതിനകം തന്നെ മാറ്റങ്ങൾ വരുത്തിയതായി കരുതുക
നിങ്ങൾ രണ്ടുപേരും യഥാർത്ഥ കമ്മിറ്റ് X നേടിയ യഥാർത്ഥ ശേഖരത്തിൽ നിന്നാണ്.

മറ്റൊരാൾ നടത്തിയ പുഷ് കമ്മിറ്റ് എക്‌സ് ലേക്ക് പോയിന്റ് ചെയ്‌തിരുന്ന ബ്രാഞ്ച് അപ്‌ഡേറ്റ് ചെയ്‌തു
പോയിന്റ് അറ്റ് കമ്മിറ്റ് എ. ഇതൊരു ഫാസ്റ്റ് ഫോർവേഡാണ്.

എന്നാൽ നിങ്ങൾ പുഷ് ചെയ്യാൻ ശ്രമിക്കുകയാണെങ്കിൽ, നിങ്ങൾ ബ്രാഞ്ച് അപ്ഡേറ്റ് ചെയ്യാൻ ശ്രമിക്കും (ഇപ്പോൾ അത് എ-ൽ പോയിന്റ് ചെയ്യുന്നു).
B. ഇത് ചെയ്യുന്നു അല്ല അതിവേഗം മുന്നോട്ട്. നിങ്ങൾ അങ്ങനെ ചെയ്‌തെങ്കിൽ, കമ്മിറ്റ് എ അവതരിപ്പിച്ച മാറ്റങ്ങൾ
നഷ്ടപ്പെടും, കാരണം എല്ലാവരും ഇപ്പോൾ ബിയുടെ മുകളിൽ പണിയാൻ തുടങ്ങും.

ഡിഫോൾട്ടായി കമാൻഡ് അത്തരം തടയുന്നതിന് ഫാസ്റ്റ് ഫോർവേഡ് അല്ലാത്ത ഒരു അപ്ഡേറ്റ് അനുവദിക്കുന്നില്ല
ചരിത്രത്തിന്റെ നഷ്ടം.

നിങ്ങളുടെ ജോലി (എക്സ് മുതൽ ബി വരെയുള്ള ചരിത്രം) അല്ലെങ്കിൽ മറ്റൊരാളുടെ സൃഷ്ടി നഷ്ടപ്പെടാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ലെങ്കിൽ
(എക്സ് മുതൽ എ വരെയുള്ള ചരിത്രം), നിങ്ങൾ ആദ്യം റിപ്പോസിറ്ററിയിൽ നിന്ന് ചരിത്രം എടുക്കേണ്ടതുണ്ട്,
രണ്ട് കക്ഷികളും വരുത്തിയ മാറ്റങ്ങൾ ഉൾക്കൊള്ളുന്ന ഒരു ചരിത്രം സൃഷ്ടിക്കുക, ഫലം പിന്നോട്ട് തള്ളുക.

നിങ്ങൾക്ക് "ജിറ്റ് പുൾ" നടത്താനും സാധ്യതയുള്ള പൊരുത്തക്കേടുകൾ പരിഹരിക്കാനും ഫലം "ജിറ്റ് പുഷ്" ചെയ്യാനും കഴിയും. ഒരു "ജിറ്റ്
പുൾ" എന്നത് എ, ബി കമ്മിറ്റുകൾക്കിടയിൽ ഒരു ലയന കമ്മിറ്റ് സി സൃഷ്ടിക്കും.

ബി---സി
/ /
---X---എ

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

പകരമായി, "ജിറ്റ് പുൾ" ഉപയോഗിച്ച് നിങ്ങൾക്ക് X-നും B-യ്ക്കും ഇടയിലുള്ള മാറ്റം A-യുടെ മുകളിൽ റീബേസ് ചെയ്യാം
--rebase", കൂടാതെ ഫലം പിന്നിലേക്ക് തള്ളുക. റീബേസ് നിർമ്മിക്കുന്ന ഒരു പുതിയ കമ്മിറ്റ് ഡി സൃഷ്ടിക്കും
A യുടെ മുകളിൽ X, B എന്നിവയ്ക്കിടയിൽ മാറ്റം വരുത്തുക.

ബി.ഡി.
/ /
---X---എ

വീണ്ടും, ഈ പ്രതിബദ്ധതയോടെ A അപ്‌ഡേറ്റ് ചെയ്യുന്നത് വേഗത്തിൽ മുന്നോട്ട് പോകുകയും നിങ്ങളുടെ പുഷ് സ്വീകരിക്കുകയും ചെയ്യും.

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

ഉദാഹരണങ്ങൾ

git push
ജിറ്റ് പുഷ് പോലെ പ്രവർത്തിക്കുന്നു , എവിടെ നിലവിലെ ബ്രാഞ്ചിന്റെ റിമോട്ട് (അല്ലെങ്കിൽ
ഉത്ഭവം, നിലവിലെ ബ്രാഞ്ചിനായി റിമോട്ട് കോൺഫിഗർ ചെയ്തിട്ടില്ലെങ്കിൽ).

git പുഷ് ഉത്ഭവം
അധിക കോൺഫിഗറേഷൻ കൂടാതെ, നിലവിലെ ബ്രാഞ്ച് ക്രമീകരിച്ച അപ്സ്ട്രീമിലേക്ക് തള്ളുന്നു
(remote.origin.merge കോൺഫിഗറേഷൻ വേരിയബിൾ) അതിന് നിലവിലുള്ളതിന്റെ അതേ പേരുണ്ടെങ്കിൽ
ബ്രാഞ്ച്, കൂടാതെ മറ്റുവിധത്തിൽ തള്ളാതെ പിശകുകൾ.

ഇല്ലെങ്കിൽ ഈ കമാൻഡിന്റെ ഡിഫോൾട്ട് സ്വഭാവം നൽകിയിരിക്കുന്നത് കോൺഫിഗർ ചെയ്യാൻ കഴിയും
റിമോട്ടിന്റെ പുഷ് ഓപ്ഷൻ അല്ലെങ്കിൽ push.default കോൺഫിഗറേഷൻ വേരിയബിൾ ക്രമീകരിക്കുന്നു.

ഉദാഹരണത്തിന്, നിലവിലെ ബ്രാഞ്ച് മാത്രം ഒറിജിനിലേക്ക് തള്ളുന്നതിന് സ്ഥിരസ്ഥിതിയായി git config ഉപയോഗിക്കുക
remote.origin.push HEAD. ഏതെങ്കിലും സാധുതയുള്ള (ചുവടെയുള്ള ഉദാഹരണങ്ങളിലെ പോലെ) കഴിയും
ജിറ്റ് പുഷ് ഒറിജിനിന്റെ ഡിഫോൾട്ടായി കോൺഫിഗർ ചെയ്യുക.

git പുഷ് ഉത്ഭവം:
"പൊരുത്തമുള്ള" ശാഖകൾ ഉത്ഭവത്തിലേക്ക് തള്ളുക. കാണുക മുകളിലുള്ള ഓപ്‌ഷൻസ് വിഭാഗത്തിൽ a
"പൊരുത്തമുള്ള" ശാഖകളുടെ വിവരണം.

ജിറ്റ് പുഷ് ഒറിജിനൽ മാസ്റ്റർ
ഉറവിട ശേഖരണത്തിൽ മാസ്റ്ററുമായി പൊരുത്തപ്പെടുന്ന ഒരു റെഫർ കണ്ടെത്തുക (മിക്കവാറും, അത് കണ്ടെത്തും
refs/heads/master), കൂടാതെ ഉത്ഭവത്തിലുള്ള അതേ ref (ഉദാ. refs/heads/master) അപ്‌ഡേറ്റ് ചെയ്യുക
അതിനൊപ്പം ശേഖരം. മാസ്റ്റർ വിദൂരമായി നിലവിലില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കപ്പെടും.

git പുഷ് ഉത്ഭവം HEAD
റിമോട്ടിൽ നിലവിലെ ബ്രാഞ്ച് അതേ പേരിലേക്ക് തള്ളാനുള്ള ഒരു എളുപ്പവഴി.

git push mothership master:satellite/master dev:satellite/dev
റഫറൻസ് അപ്‌ഡേറ്റ് ചെയ്യുന്നതിന് മാസ്റ്ററുമായി പൊരുത്തപ്പെടുന്ന ഉറവിടം റെഫർ ഉപയോഗിക്കുക (ഉദാ. റഫറൻസ്/ഹെഡുകൾ/മാസ്റ്റർ).
ഉപഗ്രഹം/മാസ്റ്റർ (മിക്കവാറും റെഫുകൾ/റിമോട്ട്/സാറ്റലൈറ്റ്/മാസ്റ്റർ) എന്നിവയുമായി പൊരുത്തപ്പെടുന്നു
മദർഷിപ്പ് ശേഖരം; dev, satellite/dev എന്നിവയ്‌ക്കും ഇതുതന്നെ ചെയ്യുക.

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

സാറ്റലൈറ്റ് മെഷീനിൽ ഈ ജിറ്റ് പുഷ് പ്രവർത്തിപ്പിച്ചതിന് ശേഷം, നിങ്ങൾ ഇതിലേക്ക് ssh ചെയ്യും
മദർഷിപ്പും റൺ ജിറ്റും അവിടെ ലയിച്ച് ഓടിച്ച ജിറ്റ് പുളിന്റെ എമുലേഷൻ പൂർത്തിയാക്കും
ഉപഗ്രഹത്തിൽ വരുത്തിയ മാറ്റങ്ങൾ പിൻവലിക്കാൻ മദർഷിപ്പിൽ.

git പുഷ് ഉത്ഭവം HEAD:മാസ്റ്റർ
ഒറിജിൻ റിപ്പോസിറ്ററിയിലെ റിമോട്ട് റെഫ് മാച്ചിംഗ് മാസ്റ്ററിലേക്ക് നിലവിലെ ബ്രാഞ്ച് പുഷ് ചെയ്യുക.
ഈ ഫോം അതിന്റെ പ്രാദേശികമായി ചിന്തിക്കാതെ നിലവിലെ ബ്രാഞ്ച് തള്ളാൻ സൗകര്യപ്രദമാണ്
പേര്.

git പുഷ് ഒറിജിൻ മാസ്റ്റർ: refs/heads/experimental
നിലവിലെ മാസ്റ്റർ പകർത്തി ഒറിജിൻ റിപ്പോസിറ്ററിയിൽ ബ്രാഞ്ച് പരീക്ഷണാത്മകമായി സൃഷ്ടിക്കുക
ശാഖ. റിമോട്ടിൽ ഒരു പുതിയ ബ്രാഞ്ച് അല്ലെങ്കിൽ ടാഗ് സൃഷ്ടിക്കാൻ മാത്രമേ ഈ ഫോം ആവശ്യമുള്ളൂ
പ്രാദേശിക നാമവും വിദൂര നാമവും വ്യത്യസ്തമാകുമ്പോൾ ശേഖരം; അല്ലെങ്കിൽ, റഫറൻസ്
പേര് സ്വന്തമായി പ്രവർത്തിക്കും.

git പുഷ് ഉത്ഭവം: പരീക്ഷണാത്മക
ഉത്ഭവ ശേഖരത്തിൽ പരീക്ഷണവുമായി പൊരുത്തപ്പെടുന്ന ഒരു റഫറൻസ് കണ്ടെത്തുക (ഉദാ
refs/heads/experimental), അത് ഇല്ലാതാക്കുക.

git പുഷ് ഉത്ഭവം +dev:master
ഒറിജിൻ റിപ്പോസിറ്ററിയുടെ മാസ്റ്റർ ബ്രാഞ്ച് dev ബ്രാഞ്ചിനൊപ്പം അപ്‌ഡേറ്റ് ചെയ്യുക, അനുവദിക്കുന്നു
നോൺ-ഫാസ്റ്റ് ഫോർവേഡ് അപ്ഡേറ്റുകൾ. ഈ കഴിയും വിട്ടേക്കുക പരാമർശിക്കാത്തത് ചെയ്യുന്നു തൂങ്ങിക്കിടക്കുന്നു in The ഉത്ഭവം
സംഭരണിയാണ്. ഫാസ്റ്റ് ഫോർവേഡ് സാധ്യമല്ലാത്ത ഇനിപ്പറയുന്ന സാഹചര്യം പരിഗണിക്കുക:

o---o---o---A---B ഉത്ഭവം/മാസ്റ്റർ
\
X---Y---Z dev

മുകളിലുള്ള കമാൻഡ് ഉത്ഭവ ശേഖരത്തെ മാറ്റും

A---B (പേരില്ലാത്ത ശാഖ)
/
o---o---o---X---Y---Z മാസ്റ്റർ

എ, ബി കമ്മിറ്റുകൾ ഇനി ഒരു പ്രതീകാത്മക നാമമുള്ള ശാഖയിൽ ഉൾപ്പെടില്ല, അങ്ങനെ ചെയ്യും
എത്തിച്ചേരാനാകുന്നില്ല. അതുപോലെ, ഈ കമ്മിറ്റുകൾ ഒരു git gc കമാൻഡ് വഴി നീക്കം ചെയ്യും
ഉത്ഭവ ശേഖരം.

GIT

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

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