गिट-रीसेट - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

गिट-रीसेट - वर्तमान हेड को निर्दिष्ट स्थिति में रीसेट करें

SYNOPSIS

Git रीसेट करें [-क्यू] [ ] [--] ...
Git रीसेट करें (--पैच | -पी) [ ] [--] [ ...]
Git रीसेट करें [--मुलायम | --मिश्रित [-एन] | --कठोर | --मर्ज करें | --रखें] [-q] [ ]

वर्णन

पहले और दूसरे फॉर्म में, प्रविष्टियों की प्रतिलिपि बनाएँ सूचकांक के लिए. तीसरे में
प्रपत्र, वर्तमान शाखा प्रमुख (HEAD) को सेट करें , वैकल्पिक रूप से संशोधित सूचकांक और
मिलान के लिए कार्यशील वृक्ष। / सभी रूपों में डिफ़ॉल्ट HEAD है।

Git रीसेट करें [-क्यू] [ ] [--] ...
यह प्रपत्र सभी के लिए अनुक्रमणिका प्रविष्टियों को रीसेट करता है उनके राज्य में . (यह
कार्यशील वृक्ष या वर्तमान शाखा को प्रभावित नहीं करता है।)

इसका मतलब है कि git रीसेट गिट ऐड के विपरीत है .

Git रीसेट चलाने के बाद इंडेक्स प्रविष्टि को अद्यतन करने के लिए, आप इसका उपयोग कर सकते हैं गिट-चेकआउट(1)
कार्यशील ट्री के सूचकांक से सामग्री की जाँच करने के लिए। वैकल्पिक रूप से, उपयोग करना गिट-
जांच(1) और एक कमिट निर्दिष्ट करते हुए, आप एक पथ की सामग्री को कॉपी कर सकते हैं
एक ही बार में इंडेक्स और वर्किंग ट्री के प्रति प्रतिबद्ध रहें।

Git रीसेट करें (--पैच | -पी) [ ] [--] [ ...]
सूचकांक और के बीच अंतर में अंतरक्रियात्मक रूप से हंक का चयन करें
(डिफ़ॉल्ट रूप से HEAD)। चुने गए हंक को सूचकांक के विपरीत लागू किया जाता है।

इसका मतलब है कि git रीसेट -p, git add -p के विपरीत है, यानी आप इसका उपयोग कर सकते हैं
चुनिंदा रूप से हंक को रीसेट करें। का "इंटरएक्टिव मोड" अनुभाग देखें git-जोड़ें(1) कैसे सीखें
--पैच मोड को संचालित करने के लिए।

Git रीसेट करें [ ] [ ]
यह प्रपत्र वर्तमान शाखा प्रमुख को रीसेट करता है और संभवतः सूचकांक को अद्यतन करता है
(इसे के पेड़ पर रीसेट करना ) और कार्यशील वृक्ष पर निर्भर करता है . अगर
छोड़ दिया गया है, डिफ़ॉल्ट "--मिश्रित" है। निम्नलिखित में से एक होना चाहिए:

--मुलायम
इंडेक्स फ़ाइल या वर्किंग ट्री को बिल्कुल भी नहीं छूता है (लेकिन हेड को रीसेट कर देता है
, जैसा कि सभी मोड करते हैं)। यह आपकी सभी परिवर्तित फ़ाइलों को "परिवर्तन" में छोड़ देता है
प्रतिबद्ध रहें", जैसे Git हैसियत लगा देंगे.

--मिला हुआ
इंडेक्स को रीसेट करता है लेकिन कार्यशील ट्री को नहीं (यानी, परिवर्तित फ़ाइलें संरक्षित रहती हैं
लेकिन प्रतिबद्ध के लिए चिह्नित नहीं है) और जो अद्यतन नहीं किया गया है उसकी रिपोर्ट करता है। यह है
डिफ़ॉल्ट कार्रवाई।

यदि -N निर्दिष्ट है, तो हटाए गए पथों को जोड़ने के इरादे के रूप में चिह्नित किया जाता है (देखें)। git-जोड़ें(1))।

--मुश्किल
इंडेक्स और वर्किंग ट्री को रीसेट करता है। कार्य में ट्रैक की गई फ़ाइलों में कोई भी परिवर्तन
तब से पेड़ त्याग दिए जाते हैं.

--मर्ज
इंडेक्स को रीसेट करता है और वर्किंग ट्री में अलग-अलग फाइलों को अपडेट करता है
बीच में और HEAD, लेकिन उन्हें रखता है जो सूचकांक के बीच भिन्न हैं
और कार्यशील वृक्ष (अर्थात जिसमें ऐसे परिवर्तन हैं जिन्हें जोड़ा नहीं गया है)। यदि कोई फ़ाइल
वह बीच में भिन्न है और सूचकांक में अस्थिर परिवर्तन हैं, रीसेट है
निरस्त।

दूसरे शब्दों में, --merge कुछ इस तरह करता है Git पढ़ें-वृक्ष -u -m , परंतु
असंबद्ध सूचकांक प्रविष्टियों को आगे बढ़ाता है।

--रखना
इंडेक्स प्रविष्टियों को रीसेट करता है और कार्यशील ट्री में अलग-अलग फ़ाइलों को अपडेट करता है
बीच में और सिर. यदि कोई फ़ाइल जो बीच में भिन्न है और सिर
स्थानीय परिवर्तन हैं, रीसेट निरस्त कर दिया गया है।

यदि आप किसी शाखा की नवीनतम प्रतिबद्धता के अलावा किसी अन्य प्रतिबद्धता को पूर्ववत करना चाहते हैं, गिट-रिवर्ट(1) आपका है
दोस्त।

विकल्प

-क्यू, --शांत
शांत रहें, केवल त्रुटियों की रिपोर्ट करें।

उदाहरण

जोड़ें पूर्ववत करें

$ संपादित करें (1)
$ git add frotz.c filfre.c
$ मेलx (2)
$ गिट रीसेट (3)
$ git पुल git://info.example.com/ nitfol (4)

1. आप खुशी-खुशी किसी चीज़ पर काम कर रहे हैं और पाते हैं कि इन फ़ाइलों में बदलाव हैं
अच्छा आदेश। जब आप "गिट डिफ" चलाते हैं तो आप उन्हें देखना नहीं चाहते, क्योंकि आप ऐसा करने की योजना बना रहे हैं
अन्य फ़ाइलों पर काम करना और इन फ़ाइलों में परिवर्तन ध्यान भटकाने वाले होते हैं।
2. कोई आपसे खींचने के लिए कहता है, और परिवर्तन विलय के योग्य लगते हैं।
3. हालाँकि, आपने पहले ही सूचकांक को गंदा कर दिया है (अर्थात आपका सूचकांक HEAD से मेल नहीं खाता है
प्रतिबद्ध)। लेकिन आप जानते हैं कि आप जो खिंचाव करने जा रहे हैं उसका frotz.c या पर कोई प्रभाव नहीं पड़ता है
filfre.c, ताकि आप इन दो फ़ाइलों के लिए अनुक्रमणिका परिवर्तन पूर्ववत कर सकें। कामकाज में आपके बदलाव
पेड़ वहीं रहे.
4. फिर आप frotz.c और filfre.c परिवर्तनों को अभी भी छोड़कर, खींच और मर्ज कर सकते हैं
काम करने वाला पेड़.

किसी कमिट को पूर्ववत करें और पुनः करें

$ गिट कमिट...
$ गिट रीसेट--सॉफ्ट हेड^ (1)
$ संपादित करें (2)
$ गिट कमिट -ए -सी ORIG_HEAD (3)

1. ऐसा अक्सर तब किया जाता है जब आपको याद आता है कि आपने अभी-अभी जो किया है वह अधूरा है,
या आपने अपना प्रतिबद्ध संदेश ग़लत लिखा है, या दोनों। पेड़ के पत्ते पहले की तरह काम करते हैं
"रीसेट"।
2. कार्यशील ट्री फ़ाइलों में सुधार करें।
3. "रीसेट" पुराने हेड को .git/ORIG_HEAD पर कॉपी करता है; इसके साथ शुरुआत करके कमिट को दोबारा करें
लॉग संदेश. यदि आपको संदेश को आगे संपादित करने की आवश्यकता नहीं है, तो आप -C विकल्प दे सकते हैं
बजाय.

--संशोधन विकल्प भी देखें Git-लिखें(1).

किसी प्रतिबद्धता को पूर्ववत करें, उसे एक विषय शाखा बनाएं

$ git शाखा विषय/wip (1)
$ गिट रीसेट--हार्ड हेड~3 (2)
$ गिट चेकआउट विषय/वाइप (3)

1. आपने कुछ प्रतिबद्धताएं बनाई हैं, लेकिन एहसास हुआ कि वे "मास्टर" बनने के लिए समय से पहले थीं
शाखा। आप उन्हें विषय शाखा में निखारना जारी रखना चाहते हैं, इसलिए "विषय/वाइप" बनाएं
वर्तमान प्रमुख से अलग शाखा।
2. उन तीन प्रतिबद्धताओं से छुटकारा पाने के लिए मास्टर शाखा को रिवाइंड करें।
3. "विषय/वाइप" शाखा पर स्विच करें और काम करना जारी रखें।

पूर्ववत स्थायी रूप से करता है

$ गिट कमिट...
$ गिट रीसेट--हार्ड हेड~3 (1)

1. पिछले तीन कमिट (HEAD, HEAD^, और HEAD~2) ख़राब थे और आप ऐसा नहीं करना चाहते
उन्हें दोबारा कभी देखना. करना नहीं यदि आपने ये कमिट पहले ही दे दी है तो ऐसा करें
किसी औ। ("अपस्ट्रीम रीबेस से पुनर्प्राप्ति" अनुभाग देखें git-rebase(1) के लिए
ऐसा करने के निहितार्थ।)

किसी मर्ज या पुल को पूर्ववत करें

$ गिट पुल (1)
ऑटो-मर्जिंग नाइटफोल
संघर्ष (सामग्री): संघर्ष को नाइटफोल में मर्ज करें
स्वचालित विलय विफल; विवादों को ठीक करें और फिर परिणाम दें।
$ गिट रीसेट--हार्ड (2)
$ गिट पुल। विषय/शाखा (3)
41223... से 13134... तक अद्यतन किया जा रहा है
तेजी से आगे बढ़ना
$ गिट रीसेट--हार्ड ORIG_HEAD (4)

1. अपस्ट्रीम से अपडेट करने की कोशिश के परिणामस्वरूप बहुत सारे टकराव हुए; आप तैयार नहीं थे
अभी विलय करने में बहुत समय लगना है, इसलिए आप इसे बाद में करने का निर्णय लेते हैं।
2. "पुल" ने मर्ज कमिट नहीं किया है, इसलिए "गिट रीसेट --हार्ड" जो "गिट" का पर्याय है
रीसेट --हार्ड हेड" इंडेक्स फ़ाइल और कार्यशील ट्री से गड़बड़ी को साफ़ करता है।
3. एक विषय शाखा को वर्तमान शाखा में मर्ज करें, जिसके परिणामस्वरूप तेजी से आगे बढ़ा।
4. लेकिन आपने निर्णय लिया कि विषय शाखा अभी तक सार्वजनिक उपभोग के लिए तैयार नहीं है।
"पुल" या "मर्ज" हमेशा वर्तमान शाखा के मूल सिरे को ORIG_HEAD में छोड़ता है,
इसलिए इसे हार्ड रीसेट करने से आपकी इंडेक्स फ़ाइल और कार्यशील ट्री वापस उसी पर आ जाता है
राज्य, और शाखा की नोक को उस प्रतिबद्धता पर रीसेट करता है।

मर्ज को पूर्ववत करें या गंदे कार्यशील पेड़ को अंदर खींचें

$ गिट पुल (1)
ऑटो-मर्जिंग नाइटफोल
पुनरावर्ती द्वारा बनाया गया विलय.
नाइटफोल | 20 +++++----
...
$ गिट रीसेट--मर्ज ORIG_HEAD (2)

1. भले ही आपके कामकाजी पेड़ में स्थानीय संशोधन हों, आप सुरक्षित रूप से कह सकते हैं
"गिट पुल" जब आप जानते हैं कि दूसरी शाखा में परिवर्तन ओवरलैप नहीं होता है
उन्हें.
2. विलय के परिणाम का निरीक्षण करने के बाद, आप पा सकते हैं कि दूसरे में परिवर्तन हुआ है
शाखा असंतोषजनक है. "गिट रीसेट --हार्ड ORIG_HEAD" चलाने से आप वापस जा सकेंगे
आप कहां थे, लेकिन यह आपके स्थानीय परिवर्तनों को हटा देगा, जो आप नहीं चाहते हैं। "गिट
रीसेट--मर्ज" आपके स्थानीय परिवर्तनों को बनाए रखता है।

बाधित कार्यप्रवाह
मान लीजिए कि आप किसी अत्यावश्यक समाधान अनुरोध के कारण बाधित हो गए हैं, जब आप बीच में हैं
बड़ा बदलाव. आपके वर्किंग ट्री की फ़ाइलें अभी प्रतिबद्ध होने लायक किसी भी आकार में नहीं हैं,
लेकिन त्वरित बग समाधान के लिए आपको दूसरी शाखा में जाना होगा।

$ git चेकआउट सुविधा ;# आप "फ़ीचर" शाखा में काम कर रहे थे और
$ काम काम काम ;#बाधित हो गया
$ गिट कमिट -ए -एम "स्नैपशॉट डब्ल्यूआईपी" (1)
$ गिट चेकआउट मास्टर
$ ठीक करो ठीक करो ठीक करो
$ git कमिट ;# वास्तविक लॉग के साथ कमिट करें
$ गिट चेकआउट सुविधा
$ git रीसेट --सॉफ्ट हेड^ ;# WIP स्थिति पर वापस जाएं (2)
$ गिट रीसेट (3)

1. यह प्रतिबद्धता ख़त्म हो जाएगी इसलिए थ्रो-अवे लॉग संदेश ठीक है।
2. यह हटा देता है विप कमिट हिस्ट्री से कमिट करें, और अपना वर्किंग ट्री सेट करें
आपके द्वारा वह स्नैपशॉट बनाने से ठीक पहले की स्थिति।
3. इस बिंदु पर इंडेक्स फ़ाइल में अभी भी आपके द्वारा किए गए सभी WIP परिवर्तन मौजूद हैं
स्नैपशॉट विप. यह आपकी WIP फ़ाइलों को अनकमिटेड दिखाने के लिए इंडेक्स को अपडेट करता है।

यह भी देखें git-stash(1).

अनुक्रमणिका में एकल फ़ाइल को रीसेट करें
मान लीजिए कि आपने अपनी अनुक्रमणिका में एक फ़ाइल जोड़ी है, लेकिन बाद में निर्णय लेते हैं कि आप जोड़ना नहीं चाहते हैं
यह आपकी प्रतिबद्धता के लिए है। आप अपने परिवर्तन रखते हुए फ़ाइल को अनुक्रमणिका से हटा सकते हैं
गिट रीसेट के साथ।

$ गिट रीसेट -- frotz.c (1)
$ git कमिट -m "इंडेक्स में फ़ाइलें कमिट करें" (2)
$ git frotz.c जोड़ें (3)

1. यह फ़ाइल को कार्यशील निर्देशिका में रखते हुए इंडेक्स से हटा देता है।
2. यह सूचकांक में अन्य सभी परिवर्तन करता है।
3. फ़ाइल को फिर से अनुक्रमणिका में जोड़ता है।

पिछले कुछ कमिटों को त्यागते हुए वर्किंग ट्री में बदलाव रखें
मान लीजिए कि आप किसी चीज़ पर काम कर रहे हैं और आप इसे प्रतिबद्ध करते हैं, और फिर आप काम करना जारी रखते हैं
थोड़ा और, लेकिन अब आप सोचते हैं कि आपके कामकाजी पेड़ में जो कुछ है वह उसमें होना चाहिए
एक अन्य शाखा जिसका आपके द्वारा पहले किए गए अपराध से कोई लेना-देना नहीं है। तुम कर सकते हो
एक नई शाखा शुरू करें और अपने कामकाजी पेड़ में बदलावों को ध्यान में रखते हुए इसे रीसेट करें।

$ गिट टैग प्रारंभ
$ गिट चेकआउट -बी शाखा1
$ संपादित करें
$ गिट कमिट... (1)
$ संपादित करें
$ गिट चेकआउट -बी शाखा2 (2)
$ गिट रीसेट--प्रारंभ रखें (3)

1. यह शाखा1 में आपका पहला संपादन करता है।
2. आदर्श दुनिया में, आप महसूस कर सकते थे कि पहले की प्रतिबद्धता प्रासंगिक नहीं थी
जब आपने नया विषय बनाया और शाखा2 पर स्विच किया (यानी "git checkout -b
शाखा2 प्रारंभ"), लेकिन कोई भी पूर्ण नहीं है।
3. लेकिन आप स्विच करने के बाद अवांछित कमिट को हटाने के लिए "रीसेट --कीप" का उपयोग कर सकते हैं
"शाखा2"।

चर्चा

नीचे दी गई तालिकाएँ दिखाती हैं कि दौड़ते समय क्या होता है:

गिट रीसेट--विकल्प लक्ष्य

विभिन्न रीसेट विकल्पों के आधार पर HEAD को किसी अन्य कमिट (लक्ष्य) पर रीसेट करना
फ़ाइलों की स्थिति.

इन तालिकाओं में, ए, बी, सी और डी एक फ़ाइल की कुछ अलग-अलग स्थितियाँ हैं। उदाहरण के लिए, पहला
पहली तालिका की पंक्ति का अर्थ है कि यदि कोई फ़ाइल कार्यशील ट्री में राज्य ए में है, तो राज्य बी में
सूचकांक में, राज्य C में HEAD में और राज्य D में लक्ष्य में, फिर "git रीसेट --soft
लक्ष्य" फ़ाइल को राज्य ए में कार्यशील ट्री में और राज्य बी में सूचकांक में छोड़ देगा
HEAD (यानी वर्तमान शाखा की नोक, यदि आप एक पर हैं) को रीसेट करता है (यानी स्थानांतरित करता है)।
"लक्ष्य" (जिसमें फ़ाइल राज्य डी में है)।

वर्किंग इंडेक्स हेड टारगेट वर्किंग इंडेक्स हेड
-------------------------------------------------- -
एबीसीडी--सॉफ्ट एबीडी
--मिश्रित जोड़ें
--हार्ड डीडीडी
--विलय (अस्वीकृत)
--रखें (अस्वीकृत)

वर्किंग इंडेक्स हेड टारगेट वर्किंग इंडेक्स हेड
-------------------------------------------------- -
एबीसीसी--सॉफ्ट एबीसी
--मिश्रित एसीसी
--हार्ड सीसीसी
--विलय (अस्वीकृत)
--एसीसी रखें

वर्किंग इंडेक्स हेड टारगेट वर्किंग इंडेक्स हेड
-------------------------------------------------- -
बीबीसीडी--सॉफ्ट बीबीडी
--मिश्रित बीडीडी
--हार्ड डीडीडी
--डीडीडी को मर्ज करें
--रखें (अस्वीकृत)

वर्किंग इंडेक्स हेड टारगेट वर्किंग इंडेक्स हेड
-------------------------------------------------- -
बीबीसीसी--सॉफ्ट बीबीसी
--मिश्रित बीसीसी
--हार्ड सीसीसी
- सीसीसी मर्ज करें
--बीसीसी रखें

वर्किंग इंडेक्स हेड टारगेट वर्किंग इंडेक्स हेड
-------------------------------------------------- -
बीसीसीडी--सॉफ्ट बीसीडी
--मिश्रित बीडीडी
--हार्ड डीडीडी
--विलय (अस्वीकृत)
--रखें (अस्वीकृत)

वर्किंग इंडेक्स हेड टारगेट वर्किंग इंडेक्स हेड
-------------------------------------------------- -
बीसीसीसी--सॉफ्ट बीसीसी
--मिश्रित बीसीसी
--हार्ड सीसीसी
--बीसीसी मर्ज करें
--बीसीसी रखें

"रीसेट --मर्ज" का उपयोग किसी विवादित मर्ज से रीसेट करते समय किया जाता है। कोई भी विलय
ऑपरेशन गारंटी देता है कि मर्ज में शामिल कार्यशील ट्री फ़ाइल शामिल नहीं है
प्रारंभ होने से पहले सूचकांक में स्थानीय परिवर्तन होता है, और यह परिणाम को लिखता है
काम करने वाला पेड़. तो अगर हम सूचकांक और लक्ष्य के बीच कुछ अंतर देखते हैं और भी
इंडेक्स और वर्किंग ट्री के बीच, तो इसका मतलब है कि हम ए से रीसेट नहीं कर रहे हैं
बताएं कि एक विलय ऑपरेशन एक संघर्ष के साथ विफल होने के बाद छोड़ दिया गया। इसीलिए हम मना करते हैं
- इस मामले में विकल्प मर्ज करें।

"रीसेट --कीप" का उपयोग वर्तमान में कुछ अंतिम कमिट को हटाते समय किया जाना है
कार्यशील वृक्ष में परिवर्तन रखते हुए शाखा। अगर आपस में टकराव हो सकता है
कमिट में परिवर्तन जिसे हम हटाना चाहते हैं और कार्यशील ट्री में परिवर्तन जो हम करना चाहते हैं
रखें, रीसेट की अनुमति नहीं है। इसलिए दोनों परिवर्तन होने पर इसे अस्वीकार कर दिया जाता है
कार्यशील वृक्ष और HEAD के बीच, और HEAD और लक्ष्य के बीच। सुरक्षित रहने के लिए यह भी है
असंबद्ध प्रविष्टियाँ होने पर अस्वीकृत।

निम्नलिखित तालिकाएँ दिखाती हैं कि जब असंबद्ध प्रविष्टियाँ होती हैं तो क्या होता है:

वर्किंग इंडेक्स हेड टारगेट वर्किंग इंडेक्स हेड
-------------------------------------------------- -
XUAB--सॉफ्ट (अस्वीकृत)
--मिश्रित एक्सबीबी
--हार्ड बीबीबी
--बीबीबी को मर्ज करें
--रखें (अस्वीकृत)

वर्किंग इंडेक्स हेड टारगेट वर्किंग इंडेक्स हेड
-------------------------------------------------- -
XUAA--सॉफ्ट (अस्वीकृत)
--मिश्रित XAA
--हार्ड एएए
- एएए मर्ज करें
--रखें (अस्वीकृत)

X का अर्थ है कोई भी अवस्था और U का अर्थ है एक असंबद्ध सूचकांक।

GIT

का हिस्सा Git(1) सुइट

onworks.net सेवाओं का उपयोग करके ऑनलाइन git-reset का उपयोग करें