git Mercurial और गिट के बीच क्या अंतर है?




version-control comparison (25)

Bitbucket.org के mercurial और github के गिट के बीच ध्यान देने योग्य एक बात यह है कि, जैसा कि आप चाहें उतने निजी भंडार हो सकते हैं, लेकिन जिथब आपको एक भुगतान खाते में अपग्रेड करना होगा। इसलिए, यही कारण है कि मैं बिटबकेट के लिए जाता हूं जो कि मर्कुरियल का उपयोग करता है।

https://code.i-harness.com

मैं विंडोज़ (msysGit के साथ) पर कुछ समय के लिए गिट का उपयोग कर रहा हूं और मुझे वितरित स्रोत नियंत्रण का विचार पसंद है। हाल ही में मैं Mercurial (एचजी) देख रहा था और यह दिलचस्प लग रहा है। हालांकि, मैं अपने सिर को एचजी और गिट के बीच मतभेदों के चारों ओर लपेट नहीं सकता।

क्या किसी ने गिट और एचजी के बीच साइड-बाय-साइड तुलना की है? मुझे यह जानने में दिलचस्पी है कि फैनबॉय चर्चा में कूदने के बिना एचजी और गिट क्या भिन्न है।



अगर मैं उन्हें सही ढंग से समझता हूं (और मैं प्रत्येक पर एक विशेषज्ञ से बहुत दूर हूं) तो मूल रूप से प्रत्येक के पास एक अलग दर्शन होता है। मैंने पहली बार 9 महीनों के लिए Mercurial का इस्तेमाल किया। अब मैंने 6 के लिए गिट का उपयोग किया है।

एचजी संस्करण नियंत्रण सॉफ्टवेयर है। इसका मुख्य लक्ष्य सॉफ्टवेयर के एक टुकड़े के संस्करणों को ट्रैक करना है।

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

एचजी में, पूरी परियोजना का इतिहास है जो हमेशा बनाए रखने की कोशिश करता है। डिफ़ॉल्ट रूप से मेरा मानना ​​है कि एचजी सभी उपयोगकर्ताओं द्वारा धक्का और खींचते समय सभी ऑब्जेक्ट्स में सभी बदलाव चाहता है।

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

जहां तक ​​गिट का संबंध है, वहां कोई "1 परियोजना" नहीं है। आपके पास एक ही रेपो में 50 परियोजनाएं हो सकती हैं और गिट की परवाह नहीं होगी। प्रत्येक को एक ही रेपो में अलग से प्रबंधित किया जा सकता है और ठीक रह सकता है।

शाखाओं की एचजी की अवधारणा मुख्य परियोजना या शाखाओं से शाखाओं की शाखाओं से शाखाएं है। गिट की ऐसी कोई अवधारणा नहीं है। गिट में एक शाखा पेड़ की एक राज्य है, सब कुछ गिट में एक शाखा है। कौन सी शाखा आधिकारिक, वर्तमान, या नवीनतम का गिट में कोई मतलब नहीं है।

मुझे नहीं पता कि क्या इसका कोई मतलब है। अगर मैं चित्र खींच सकता हूं तो शायद ऐसा लगता है कि प्रत्येक प्रतिबद्धता o

             o---o---o
            /        
o---o---o---o---o---o---o---o
         \         /
          o---o---o

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

o---o---o---o---o

o---o---o---o
         \
          o---o

o---o---o---o

वास्तव में कुछ तरीकों से यह गिट में शाखाओं को दिखाने के लिए भी समझ में नहीं आता है।

एक बात जो चर्चा, गिट और मर्कुरियल दोनों के लिए बहुत भ्रमित है, दोनों को "शाखा" कहा जाता है लेकिन वे दूरस्थ रूप से एक ही चीज़ नहीं हैं। Mercurial में एक शाखा के बारे में आता है जब विभिन्न repos के बीच संघर्ष हैं। गिट में एक शाखा जाहिरा तौर पर एचजी में एक क्लोन के समान है। लेकिन एक क्लोन, जबकि यह समान व्यवहार दे सकता है, निश्चित रूप से वही नहीं है। मुझे क्रोमियम रेपो का उपयोग करके गिट बनाम एचजी में कोशिश करने पर विचार करें जो कि काफी बड़ा है।

$ time git checkout -b some-new-branch
Switched to new branch 'some-new-branch'

real   0m1.759s
user   0m1.596s
sys    0m0.144s

और अब क्लोन का उपयोग कर एचजी में

$ time hg clone project/ some-clone/

updating to branch default
29387 files updated, 0 files merged, 0 files removed, 0 files unresolved.
real   0m58.196s
user   0m19.901s
sys    0m8.957

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

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

git checkout master
git checkout -b add-2nd-joypad-support
git checkout master
git checkout -b fix-game-save-bug
git checkout master
git checkout -b add-a-star-support

इसने सिर्फ 3 शाखाएं बनाईं, प्रत्येक मास्टर नामक शाखा से आधारित है। (मुझे यकीन है कि गिट में कुछ जगहों के बजाय प्रत्येक 1 लाइन बनाने के लिए कुछ तरीका है)

अब एक पर काम करने के लिए मैं बस करता हूँ

git checkout fix-game-save-bug

और काम करना शुरू करें। चीजों को कम करें, आदि। क्रोम के रूप में बड़ी परियोजना में भी शाखाओं के बीच स्विचिंग लगभग तात्कालिक है। मैं वास्तव में नहीं जानता कि एचजी में ऐसा कैसे करें। यह मैंने पढ़े गए किसी भी ट्यूटोरियल का हिस्सा नहीं है।

एक और बड़ा अंतर। गिट का मंच

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

तब मंच का क्या मतलब है? आप आसानी से अपनी प्रतिबद्धता को अलग कर सकते हैं। कल्पना कीजिए कि आपने joypad.cpp और gamesave.cpp संपादित किया है और आप उन्हें अलग से प्रतिबद्ध करना चाहते हैं

git add joypad.cpp  // copies to stage
git commit -m "added 2nd joypad support"
git add gamesave.cpp  // copies to stage
git commit -m "fixed game save bug"

गिट में यह भी तय करने के लिए आदेश हैं कि उसी फ़ाइल में कौन सी विशेष लाइनें आप मंच पर प्रतिलिपि बनाना चाहते हैं ताकि आप अलग-अलग काम कर सकें। आप ऐसा क्यों करना चाहते हो? क्योंकि अलग-अलग काम करता है क्योंकि दूसरों को केवल वे चाहते हैं जो वे चाहते हैं या यदि कोई समस्या हो तो वे केवल उस प्रतिबद्धता को वापस कर सकते हैं जिस पर समस्या थी।



कुछ भी तो नहीं। वे दोनों समान करते हैं, दोनों समान रूप से प्रदर्शन करते हैं। एकमात्र कारण आपको एक दूसरे को चुनना चाहिए यदि आप किसी ऐसे प्रोजेक्ट में मदद करते हैं जो पहले से ही एक का उपयोग करता है ..

एक चुनने का दूसरा संभावित कारण एक ऐसा एप्लिकेशन या सेवा है जो केवल सिस्टम में से किसी एक का समर्थन करता है .. उदाहरण के लिए, मैंने गिटूब की वजह से गिट सीखना चुना है ..


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

Mercurial एक अलग मानसिकता के साथ बनाया गया है। डेवलपर्स को वीसीएस के बारे में ज्यादा परवाह नहीं करना चाहिए, और उन्हें अपना मुख्य कार्य अपने मुख्य समारोह पर खर्च करना चाहिए: सॉफ्टवेयर इंजीनियरिंग। Mercurial उपयोगकर्ताओं को किसी भी गैर-पुनर्प्राप्ति योग्य गलतियों के बिना सिस्टम का उपयोग करने और खुशी से दुरुपयोग करने की अनुमति देता है।

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

उदाहरण देने के लिए, मान लीजिए कि आप गलती से प्रतिबद्ध हैं। आप कुछ फाइलों को संपादित करना भूल गए हैं। Mercurial में कार्रवाई को पूर्ववत करने के लिए आप बस टाइप करें:

$ hg rollback

फिर आपको एक संदेश मिलता है कि सिस्टम आपके पिछले लेनदेन को पूर्ववत करता है।

गिट में आपको टाइप करना होगा:

$ git reset --soft HEAD^

तो ठीक है मान लीजिए कि आपको पता है कि रीसेट क्या है। लेकिन इसके अलावा आपको यह जानना होगा कि "- सॉफ्ट" और "--हार्ड" रीसेट क्या हैं (कोई अंतर्ज्ञानी अनुमान?)। ओह और निश्चित रूप से अंत में '^' चरित्र को मत भूलना! (अब रिची के नाम में क्या है ...)

तीसरे पक्ष के उपकरण जैसे किडीएफ 3 और मेल्ड के साथ मर्कुरियल का एकीकरण भी बेहतर है। अपने पैच को अपनी शाखाओं को बिना किसी झगड़े के मर्ज करें। Mercurial में एक साधारण http सर्वर भी शामिल है जिसे आप टाइप करके सक्रिय करते हैं

hg serve

और दूसरों को अपनी भंडार ब्राउज़ करने दें।

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


क्या आपके प्रोजेक्ट पर कोई विंडोज-आधारित सहयोगी है?

क्योंकि यदि वहां हैं, तो गिट-फॉर-विंडोज जीयूआई अजीब, मुश्किल, असभ्य लगता है।

इसके विपरीत, Mercurial-on-Windows, एक ब्रेनर है।


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

वह अंतर का सार है।

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

कुछ और तकनीकी-उन्मुख तुलनाओं के लिए, मैंने जो व्यक्तिगत लेख व्यक्तिगत रूप से देखा है, वे डस्टिन सेलिंग्स हैं:

उन्होंने वास्तव में दोनों डीवीसीएस का व्यापक रूप से उपयोग किया है और उन्हें दोनों अच्छी तरह से समझते हैं - और गिट पसंद करते हैं।


जब शाखाओं (विशेष रूप से अल्पकालिक वाले) के साथ काम करने की बात आती है तो इसमें काफी महत्वपूर्ण अंतर होते हैं।

यह इस आलेख में समझाया गया है (ब्रांचिंग एक्स्प्लेन्डेन) जो कि गिट के साथ Mercurial की तुलना करता है।


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

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


फिर भी Mercurial और गिट की एक और दिलचस्प तुलना: Mercurial बनाम गिट । मुख्य फोकस आंतरिक और शाखाओं की प्रक्रिया पर उनके प्रभाव पर है।


मुझे एहसास है कि यह उत्तर का हिस्सा नहीं है, लेकिन उस नोट पर, मुझे यह भी लगता है कि नेटबीन और ग्रहण जैसे प्लेटफार्मों के लिए स्थिर प्लगइन की उपलब्धता एक ऐसा हिस्सा निभाती है जिसमें उपकरण कार्य के लिए बेहतर फिट है, या बल्कि, कौन सा टूल "आप" के लिए सबसे अच्छा फिट है। यही है, जब तक कि आप वास्तव में इसे सीएलआई-रास्ता नहीं करना चाहते हैं।

ग्रहण (और इसके आधार पर सबकुछ) और नेटबीन दोनों में कभी-कभी दूरस्थ फ़ाइल सिस्टम (जैसे एसएसएच) और फ़ाइलों के बाहरी अपडेट के साथ समस्याएं होती हैं; जो कि एक और कारण है कि आप जो भी चाहते हैं वह "निर्बाध रूप से" काम करना चुनते हैं।

मैं अभी भी अपने लिए इस प्रश्न का उत्तर देने की कोशिश कर रहा हूं .. और मैंने उम्मीदवारों को गिट या मर्कुरियल में उबाला दिया है .. धार्मिकता के बिना इस विषय पर उपयोगी इनपुट प्रदान करने के लिए धन्यवाद।



मैं वर्तमान में एसवीएन से एक डीवीसीएस में माइग्रेट करने की प्रक्रिया में हूं (जबकि मेरे निष्कर्षों के बारे में ब्लॉगिंग, मेरा पहला वास्तविक ब्लॉगिंग प्रयास ...), और मैंने थोड़ा सा शोध किया है (= googling)। जहां तक ​​मैं देख सकता हूं कि आप दोनों पैकेजों के साथ अधिकांश चीजें कर सकते हैं। ऐसा लगता है कि गिट में कुछ और बेहतर कार्यान्वित उन्नत सुविधाएं हैं, मुझे लगता है कि खिड़कियों के साथ एकीकरण TortoiseHg के साथ Mercurial के लिए थोड़ा बेहतर है। मुझे पता है कि गिट चीता भी है (मैंने दोनों की कोशिश की), लेकिन मर्कुरियल समाधान बस अधिक मजबूत लगता है।

यह देखते हुए कि वे दोनों ओपन-सोर्स (दाएं?) कैसे हैं, मुझे नहीं लगता कि या तो महत्वपूर्ण विशेषताओं की कमी होगी। अगर कुछ महत्वपूर्ण है, तो लोग इसके लिए पूछेंगे, लोग इसे कोड देंगे।

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

ऐसा कहा जा रहा है कि, मुझे इस बारे में अन्य लोगों के बारे में क्या कहना है, इस बारे में मुझे रूचि है, क्योंकि यह मेरे ब्लॉगिंग प्रयासों के लिए एक महान स्रोत बना देगा ;-)


यदि आप Mercurial और Git की प्रदर्शन तुलना में रुचि रखते हैं तो इस आलेख पर एक नज़र डालें। निष्कर्ष यह है:

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


यदि आप एक विंडोज डेवलपर हैं जो मूल डिस्कनेक्ट किए गए संशोधन नियंत्रण की तलाश में हैं, तो एचजी के साथ जाएं। मैंने गिट को समझ में नहीं पाया, जबकि एचजी विंडोज शैल के साथ सरल और अच्छी तरह से एकीकृत था। मैंने एचजी डाउनलोड किया और इस ट्यूटोरियल का पालन ​​किया (hginit.com) - दस मिनट बाद मेरे पास स्थानीय रिपो था और मेरी परियोजना पर काम करने के लिए वापस आ गया।


यदि आप एसवीएन से माइग्रेट कर रहे हैं, तो Mercurial का उपयोग करें क्योंकि इसके वाक्यविन्यास एसवीएन उपयोगकर्ताओं के लिए बहुत अधिक समझदार है। इसके अलावा, आप या तो गलत नहीं जा सकते हैं। लेकिन उनमें से एक का चयन करने से पहले जीआईटी ट्यूटोरियल और एचजीनिट की जांच करें।



ये लेख मदद कर सकते हैं:

संपादित करें : हस्तियों के लिए गिट और मर्कुरियल की तुलना करना एक प्रवृत्ति प्रतीत होता है। यहां एक और है:


विंडोज़ पर बड़ा अंतर है। Mercurial मूल रूप से समर्थित है, गिट नहीं है। आप bitbucket.org के साथ github.com पर बहुत ही समान होस्टिंग प्राप्त कर सकते हैं (वास्तव में बेहतर है क्योंकि आप एक मुफ्त निजी भंडार प्राप्त करते हैं)। मैं थोड़ी देर के लिए msysGit का उपयोग कर रहा था लेकिन Mercurial में चले गए और इसके साथ बहुत खुश थे।


वे लगभग समान हैं। सबसे महत्वपूर्ण अंतर, मेरे दृष्टिकोण से (मेरा मतलब है, जिस कारण से मुझे एक डीवीसीएस चुनने के लिए मिला) यह है कि दोनों कार्यक्रम शाखाओं का प्रबंधन कैसे करते हैं।

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

संक्षेप में, Mercurial में प्रत्येक शाखा की अपनी निर्देशिका की जरूरत है; गिट में आप आमतौर पर एकल निर्देशिका में काम करते हैं। Mercurial में शाखाओं स्विचिंग मतलब निर्देशिका बदल रहा है; गिट में, इसका मतलब है कि गिट चेकआउट के साथ निर्देशिका की सामग्री को बदलने के लिए गिट पूछना।

मैं ईमानदार हूं: मुझे नहीं पता कि Mercurial के साथ ऐसा करना संभव है, लेकिन जब से मैं आमतौर पर वेब प्रोजेक्ट पर काम करता हूं, हमेशा गिट के साथ एक ही निर्देशिका का उपयोग करके मुझे बहुत confortable लगता है, क्योंकि मुझे फिर से नहीं करना है अपाचे को कॉन्फ़िगर करें और इसे पुनरारंभ करें और जब भी मैं शाखा करता हूं तो मैं अपने फाइल सिस्टम को गड़बड़ नहीं करता हूं।

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

कारण है कि बहुत से एचजी उपयोगकर्ता नामित शाखा पर क्लोन पसंद करते हैं, तकनीकी से कहीं अधिक सामाजिक या सांस्कृतिक है। उदाहरण के लिए, एचजी के अंतिम संस्करणों के साथ, नामित शाखा को बंद करना भी संभव है और परिवर्तनों से मेटाडेटा को दोबारा हटा दें।

दूसरी तरफ, गिट "नामित शाखाओं" का उपयोग करने के लिए आमंत्रित करता है जो स्थायी नहीं हैं और प्रत्येक परिवर्तन पर मेटाडेटा के रूप में संग्रहीत नहीं हैं।

मेरे व्यक्तिगत दृष्टिकोण से, फिर, गिट का मॉडल नामित शाखाओं की अवधारणा से गहराई से जुड़ा हुआ है और उसी शाखा के साथ एक शाखा और दूसरे के बीच स्विच करता है; एचजी नामित शाखाओं के साथ भी ऐसा ही कर सकता है, लेकिन फिर भी यह क्लोन के उपयोग को प्रोत्साहित करता है, जिसे मैं व्यक्तिगत रूप से बहुत पसंद नहीं करता हूं।


शब्दावली वेबसाइट में शब्दावली और अंतर्निहित अवधारणाओं के अंतर को समझाते हुए, दोनों प्रणालियों के बीच समानताएं और मतभेदों का एक बड़ा विवरण है । एक लंबे समय के गिट उपयोगकर्ता के रूप में, यह वास्तव में मेरी Mercurial मानसिकता को समझने में मदद की।



गिट और मर्कुरियल के बीच एक बड़ा अंतर है; प्रत्येक प्रतिबद्धता का प्रतिनिधित्व करने का तरीका। गिट का प्रतिनिधित्व स्नैपशॉट्स के रूप में करता है, जबकि Mercurial उन्हें diffs के रूप में दर्शाता है।

अभ्यास में इसका क्या अर्थ है? खैर, गिट में कई ऑपरेशन तेजी से होते हैं, जैसे किसी अन्य प्रतिबद्धता पर स्विच करना, काम की तुलना करना आदि। विशेष रूप से यदि ये काम बहुत दूर हैं।

AFAIK Mercurial के दृष्टिकोण का कोई फायदा नहीं है।


मैं Mercurial पर काम करता हूं, लेकिन मूल रूप से मेरा मानना ​​है कि दोनों सिस्टम समकक्ष हैं। वे दोनों एक ही सार तत्वों के साथ काम करते हैं: स्नैपशॉट्स (परिवर्तन) की एक श्रृंखला जो इतिहास बनाती है। प्रत्येक परिवर्तनक जानता है कि यह कहां से आया (मूल परिवर्तन) और इसमें कई बच्चे परिवर्तन हो सकते हैं। हाल ही में hg-git एक्सटेंशन मर्कुरियल और गिट के बीच दो तरफा पुल प्रदान करता है और इस बिंदु को दिखाता है।

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

हल्के वजन वाली शाखाओं के लिए, फिर Mercurial ने कई शाखाओं के साथ भंडारों का समर्थन किया है ..., हमेशा मुझे लगता है। कई शाखाओं के साथ गिट भंडार बिल्कुल ठीक है: एक ही भंडार में विकास के कई अलग-अलग तार। गिट फिर इन स्ट्रैंड्स में नाम जोड़ता है और आपको इन नामों को दूरस्थ रूप से पूछने की अनुमति देता है। Mercurial के लिए Bookmarks एक्सटेंशन स्थानीय नाम जोड़ता है, और Mercurial 1.6 के साथ, आप इन बुकमार्क को चारों ओर ले जा सकते हैं जब आप पुश / पुल करते हैं ..

मैं लिनक्स का उपयोग करता हूं, लेकिन स्पष्ट रूप से टोर्टोइज एचजी विंडोज पर गिट समकक्ष (तेज विंडोज फाइल सिस्टम के बेहतर उपयोग के कारण) से तेज़ और बेहतर है। Http://github.com और http://bitbucket.org दोनों ऑनलाइन होस्टिंग प्रदान करते हैं, बिटबकेट में सेवा बहुत अच्छी और उत्तरदायी है (मैंने जिथब की कोशिश नहीं की है)।

मैंने Mercurial चुना क्योंकि यह साफ और सुरुचिपूर्ण लगता है - मुझे गिट के साथ मिली शेल / पर्ल / रूबी स्क्रिप्ट्स द्वारा बंद कर दिया गया था। git-instaweb.sh फ़ाइल पर एक नज़र git-instaweb.sh प्रयास करें यदि आप जानना चाहते हैं कि मेरा क्या मतलब है: यह एक शेल स्क्रिप्ट है जो रूबी स्क्रिप्ट उत्पन्न करती है, जो मुझे लगता है कि एक वेबसर्वर चलाता है। शेल स्क्रिप्ट पहली रूबी स्क्रिप्ट लॉन्च करने के लिए एक और शेल स्क्रिप्ट उत्पन्न करती है। अच्छी माप के लिए, पर्ल का थोड़ा सा भी है।

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

git fetch <project-to-union-merge>
GIT_INDEX_FILE=.git/tmp-index git-read-tree FETCH_HEAD
GIT_INDEX_FILE=.git/tmp-index git-checkout-cache -a -u
git-update-cache --add -- (GIT_INDEX_FILE=.git/tmp-index git-ls-files)
cp .git/FETCH_HEAD .git/MERGE_HEAD
git commit

वे आदेश मेरी आंखों के लिए काफी आर्केन दिखते हैं। Mercurial में हम करते हैं:

hg pull --force <project-to-union-merge>
hg merge
hg commit

ध्यान दें कि Mercurial कमांड कैसे सादे हैं और विशेष रूप से विशेष नहीं हैं - केवल एकमात्र असामान्य बात है - --force फ्लैग hg pull , जिसकी आवश्यकता होती है क्योंकि जब आप एक असंबंधित भंडार से खींचते हैं तो Mercurial अन्यथा निरस्त हो जाएगा। यह इस तरह के मतभेद है जो Mercurial मेरे लिए अधिक सुरुचिपूर्ण लग रहा है।







dvcs