दिलचस्प पोस्ट
क्या प्रक्रिया अभी भी चल रही है? अक्षम / सक्षम बटन और लिंक (jQuery + बूटस्ट्रैप) का सबसे आसान तरीका क्या है सी # विभाजन स्ट्रिंग लेकिन विभाजित वर्ण / विभाजक रखने के लिए सी # में फ़ाइल मालिक की स्थापना / सेटिंग कैसे .net कोड से संग्रहित प्रक्रिया के लिए तालिका मान पैरामीटर को पारित करने के लिए C ++ क्लासेस में सदस्य चर पर उपसर्ग का उपयोग क्यों करें ITunesConnect से ऐप कैसे हटाएं Codeigniter: देखने के नियंत्रक से डेटा पासिंग यह जावास्क्रिप्ट "आवश्यकता" क्या है? एचटीएमएल टैग्स के रूप में एचटीएमएल टैग्स से बचने के लिए सबसे तेज़ तरीका? मैं php का उपयोग कर एक डॉकॉक्स दस्तावेज़ को html में कैसे रूपांतरित कर सकता / सकती हूं? एजेक्स में 302 रीडायरेक्ट को संभाल नहीं सकते हैं और क्यों? प्रोग्रामिंग एक वेब पेज पढ़ना मैं कमांड लाइन टूल का उपयोग करते हुए मैक ओएस एक्स के लिए एक अच्छी दिखने वाली डीएमजी कैसे बनाऊँ? 'आयात tensorflow' के बाद अजगर में त्रुटि: TypeError: __init __ () को एक अनपेक्षित कीवर्ड तर्क 'वाक्यविन्यास' मिला

मुझे git को खींचने का उपयोग कब करना चाहिए – रिबेस?

मुझे कुछ लोगों का पता है जो git pull --rebase प्रयोग करते हैं – git pull --rebase डिफ़ॉल्ट रूप से और दूसरों का कहना है कि इसका इस्तेमाल कभी नहीं करना होगा मेरा मानना ​​है कि मैं विलय और रिसाव के बीच के अंतर को समझता हूं, लेकिन मैं इसे git pull के संदर्भ में रखने की कोशिश कर रहा हूं। क्या यह बहुत सारे मर्ज कमिट संदेशों को देखने के बारे में नहीं है, या क्या अन्य मुद्दे हैं?

Solutions Collecting From Web of "मुझे git को खींचने का उपयोग कब करना चाहिए – रिबेस?"

आपको git pull --rebase इस्तेमाल करना चाहिए – git pull --rebase जब

  • आपके परिवर्तन एक अलग शाखा के लायक नहीं हैं

वास्तव में – तो क्यों नहीं? यह अधिक स्पष्ट है, और आपके कमानों पर एक तर्कसंगत समूह को लागू नहीं करता है


ठीक है, मुझे लगता है कि इसे कुछ स्पष्टीकरण की आवश्यकता है जीआईटी में, जैसा कि आप शायद जानते हैं, आपको शाखा और मर्ज करने के लिए प्रोत्साहित किया जाता है आपकी स्थानीय शाखा, जिसमें आप बदलाव लाते हैं, और दूरस्थ शाखाएं वास्तव में, विभिन्न शाखाएं हैं और git pull उन्हें विलय के बारे में है। यह उचित है, क्योंकि आप बहुत अधिक बार पुश नहीं करते हैं और आम तौर पर एक पूर्ण सुविधा का निर्माण करने से पहले कई तरह के बदलावों को जमा करते हैं।

हालांकि, कभी-कभी – जो भी कारण से – आपको लगता है कि यह वास्तव में बेहतर होगा यदि इन दोनों – दूरस्थ और स्थानीय – एक शाखा होती है एसवीएन की तरह यह यहां है जहां git pull --rebase खेल में आता है। आप अब मर्ज नहीं करते – आप वास्तव में दूरस्थ शाखा के ऊपर प्रतिबद्ध हैं यही वह वास्तव में क्या है

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

मैं वास्तव में क्या "git pull –rebase" का अर्थ है, क्योंकि यह कभी-कभी खो जाना लगता है पर एक अलग परिप्रेक्ष्य देना चाहूंगा

यदि आपने कभी तोड़फोड़ (या सीवीएस) का उपयोग किया है, तो आप "svn update" के व्यवहार के लिए उपयोग किया जा सकता है यदि आपके पास बदलाव करने के लिए परिवर्तन हैं और कमिट में विफल रहता है क्योंकि परिवर्तन अपस्ट्रीम बना हुआ है, तो आप "svn update" आपके उपरोक्त परिवर्तनों को मर्ज करके उपनिवेश प्राप्त होता है, संभावित रूप से संघर्ष होता है

क्या तोड़फोड़ अभी किया था, अनिवार्य रूप से "खींच – रिबेस" नए संस्करण के सापेक्ष होने के लिए आपके स्थानीय परिवर्तनों को फिर से तैयार करने का कार्य यह "रीबिंग" का भाग है यदि आपने असफल प्रतिबद्ध प्रयास से पहले "svn diff" किया था, और इसके परिणामस्वरूप "diff" के उत्पादन के साथ परिणामस्वरूप भिन्नता की तुलना बाद में, दो diffs के बीच का अंतर क्या है कि रिसाइज़िंग ऑपरेशन ने किया।

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

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

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

कृपया उन लोगों पर विचार करें जिनको आपकी परियोजना के इतिहास को देखने और समझने की आवश्यकता है। क्या आप चाहते हैं कि इतिहास सैकड़ों विलय से पूरी तरह से विलीन हो, या क्या आप केवल कुछ चुनिंदा विलय चाहते हैं जो जानबूझकर भिन्न विकास प्रयासों के असली विलय का प्रतिनिधित्व करते हैं?

मुझे लगता है कि आपको एक ही शाखा पर दूसरों के साथ सहयोग करते समय git pull --rebase उपयोग करना चाहिए। आप अपने काम-> प्रतिबद्ध-> काम-> प्रतिबद्ध चक्र में हैं, और जब आप अपने काम को आगे बढ़ाने का फैसला करते हैं, तो आपका पुश खारिज कर दिया जाता है क्योंकि उसी शाखा पर समानांतर कार्य किया गया है। इस बिंदु पर मैं हमेशा एक पुल -रेबेज करता हूं। मैं स्क्वैश का इस्तेमाल नहीं करता (कमाने के लिए), लेकिन मैं अतिरिक्त मर्ज कमाने से बचने के लिए दुबारा करता हूं।

जैसा कि आपका जीआईटी ज्ञान बढ़ता है, आप अपने आप को किसी भी अन्य वीसीएस के इस्तेमाल से ज्यादा इतिहास की तलाश में देखते हैं। अगर आपके पास एक छोटा सा विलय होता है, तो आपके इतिहास में होने वाली बड़ी तस्वीर का फ़ोकस कम करना आसान है।

यह वास्तव में केवल एक बार मैं (*) रिबज़ कर रहा हूं, और मेरे बाकी कार्यप्रवाह आधारित मर्ज है लेकिन जब तक आपके सबसे अधिक बार आने वाले लोग ऐसा करते हैं, तब तक इतिहास बहुत अंततः बेहतर दिखता है

— संपादित करें: (*) एक जीआईटी पाठ्यक्रम को पढ़ाने के दौरान, मुझे एक छात्र को इस पर गिरफ्तार कर लिया गया था, क्योंकि मैंने कुछ परिस्थितियों में फीचर शाखाओं को रिबीज करने की भी वकालत की थी। और उसने इस उत्तर को पढ़ लिया था;) इस तरह के रिबिंग भी संभव है, लेकिन हमेशा पूर्व-व्यवस्थित / सहमत सिस्टम के अनुसार होना चाहिए, और जैसे "हमेशा" लागू नहीं किया जाना चाहिए और उस समय मैं आमतौर पर पुल नहीं करता – रिबेस या तो, जो कि प्रश्न का है;)

शायद यह समझाने का सबसे अच्छा तरीका एक उदाहरण के साथ है:

  1. ऐलिस विषय की शाखा A बनाता है, और उस पर काम करती है
  2. बॉब असंबंधित विषय की शाखा बी बनाता है, और उस पर कार्य करता है
  3. ऐलिस git checkout master && git pull मास्टर पहले से ही अद्यतित है
  4. बॉब git checkout master && git pull मास्टर पहले से ही अद्यतित है
  5. एलिस git merge topic-branch-A
  6. बॉब git merge topic-branch-B
  7. ऐलिस एलिस से पहले बॉब git push origin master
  8. एलिस git push origin master , जिसे अस्वीकार कर दिया गया है क्योंकि यह तेजी से आगे की मर्ज नहीं है।
  9. ऐलिस मूल / मास्टर लॉग पर दिखता है, और यह देखता है कि प्रतिबद्ध उसका संबंध नहीं है।
  10. ऐलिस git pull --rebase origin master
  11. ऐलिस की मर्ज कमिट अबाध है, बॉब की प्रतिबद्धता खींची जाती है, और ऐलिस की प्रतिबद्धता बॉब की प्रतिबद्धता के बाद लागू होती है।
  12. एलिस git push origin master , और हर कोई खुश है कि भविष्य में लॉग देखे जाने पर उन्हें बेकार मर्ज कमोडिटी पढ़ना नहीं पड़ता है।

ध्यान दें कि विशिष्ट शाखा को विलय किया जा रहा है उदाहरण के लिए अप्रासंगिक है। इस उदाहरण में मास्टर के रूप में आसानी से एक रिलीज शाखा या देव शाखा हो सकता है। मुख्य बात यह है कि ऐलिस और बॉब एक ​​साथ साझा शाखाओं में अपनी स्थानीय शाखाओं को एक साथ विलय कर रहे हैं।

मुझे नहीं लगता कि कभी भी pull --rebase का उपयोग करने के लिए कोई कारण नहीं है – pull --rebase – मैंने विशेष रूप से अपने git pull कमांड को हमेशा अपस्ट्रीम कमिट के खिलाफ pull --rebase करने की अनुमति देने के लिए कोड जोड़ा

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

बस याद रखना:

  • खींच = प्राप्त करें + मर्ज करें
  • पुल – रिबेस = फ़ेच + रिबेस

इसलिए, जिस तरह से आप अपनी शाखा को संभाल करना चाहते हैं उसे चुनें

आप मर्ज और रिबेस के बीच के अंतर को बेहतर ढंग से जानते हैं 🙂

मुझे लगता है कि यह एक निजी प्राथमिकता के लिए उबाल हो जाता है

क्या आप अपने परिवर्तनों को आगे बढ़ाने से पहले अपनी गलतियों को छिपाना चाहते हैं? यदि हां, तो git pull --rebase सही है, यह आपको बाद में स्क्वैश के लिए कुछ (या एक) प्रतिबद्ध करने के लिए अनुमति देता है। यदि आपने अपने (अनारक्षित) इतिहास में विलय किया है, तो बाद में एक git rebase रिसाव करना इतना आसान नहीं है।

मैं व्यक्तिगत रूप से मेरी सारी गलतियों को प्रकाशित करने में कोई दिक्कत नहीं करता, इसलिए मैं रीबेस के बजाय मर्ज करने की कोशिश करता हूं।

git pull --rebase एक सहयोगी git push --force git pull --rebase से एक इतिहास को फिर से लिखना छुपा सकता है। मैं git pull --rebase लिए सिफारिश करता हूं – git pull --rebase केवल अगर आपको पता है कि आप अपना git pull --rebase भूल गए हैं इससे पहले कि किसी और को ऐसा करना पड़ता है

अगर आप कुछ भी नहीं करते हैं, लेकिन आपके काम के स्थान को साफ नहीं है, बस git stash को git pull से पहले git stash इस तरह से आप चुपचाप अपने इतिहास को फिर से लिखना नहीं देंगे (जो आपके चुने हुए कामों को छोड़ सकता है)