गिट - त्वरित गाइड

संस्करण नियंत्रण प्रणाली

Version Control System (VCS) एक सॉफ्टवेयर है जो सॉफ्टवेयर डेवलपर्स को एक साथ काम करने और उनके काम का पूरा इतिहास बनाए रखने में मदद करता है।

नीचे सूचीबद्ध एक VCS के कार्य हैं -

• डेवलपर्स को एक साथ काम करने की अनुमति देता है।
• एक-दूसरे के परिवर्तनों को ओवरराइट करने की अनुमति नहीं देता है।
• हर संस्करण का इतिहास रखता है।

VCS के प्रकार निम्नलिखित हैं -

• केंद्रीकृत संस्करण नियंत्रण प्रणाली (CVCS)।
• वितरित / विकेंद्रीकृत संस्करण नियंत्रण प्रणाली (DVCS)।

इस अध्याय में, हम केवल वितरित संस्करण नियंत्रण प्रणाली और विशेष रूप से गिट पर ध्यान केंद्रित करेंगे। Git वितरित संस्करण नियंत्रण प्रणाली के अंतर्गत आता है।

वितरित संस्करण नियंत्रण प्रणाली

केंद्रीकृत संस्करण नियंत्रण प्रणाली (CVCS) सभी फ़ाइलों को संग्रहीत करने के लिए एक केंद्रीय सर्वर का उपयोग करता है और टीम सहयोग को सक्षम करता है। लेकिन CVCS की बड़ी खामी केंद्रीय सर्वर की विफलता का एकमात्र बिंदु है। दुर्भाग्य से, अगर केंद्रीय सर्वर एक घंटे के लिए नीचे जाता है, तो उस घंटे के दौरान, कोई भी बिल्कुल भी सहयोग नहीं कर सकता है। और यहां तक ​​कि सबसे खराब स्थिति में, यदि केंद्रीय सर्वर की डिस्क दूषित हो जाती है और उचित बैकअप नहीं लिया गया है, तो आप परियोजना के पूरे इतिहास को खो देंगे। यहाँ, वितरित संस्करण नियंत्रण प्रणाली (DVCS) चित्र में आती है।

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

Git के फायदे

मुक्त और खुला स्रोत

Git को GPL के ओपन सोर्स लाइसेंस के तहत जारी किया गया है। यह इंटरनेट पर स्वतंत्र रूप से उपलब्ध है। आप एक पैसे का भुगतान किए बिना संपत्ति परियोजनाओं का प्रबंधन करने के लिए गिट का उपयोग कर सकते हैं। चूंकि यह एक खुला स्रोत है, आप इसके स्रोत कोड को डाउनलोड कर सकते हैं और अपनी आवश्यकताओं के अनुसार परिवर्तन भी कर सकते हैं।

तेज और छोटा

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

निहित बैकअप

जब इसकी कई प्रतियाँ होती हैं तो डेटा खोने की संभावना बहुत कम होती है। किसी भी क्लाइंट साइड पर मौजूद डेटा रिपॉजिटरी को मिरर करता है, इसलिए इसे क्रैश या डिस्क करप्शन की स्थिति में इस्तेमाल किया जा सकता है।

सुरक्षा

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

शक्तिशाली हार्डवेयर की कोई आवश्यकता नहीं है

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

आसान शाखा

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

डीवीसीएस शब्दावली

स्थानीय रिपोजिटरी

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

वर्किंग डायरेक्टरी और स्टेजिंग एरिया या इंडेक्स

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

हमें Git के मूल वर्कफ़्लो को देखने दें।

Step 1 - आप कार्यशील निर्देशिका से एक फ़ाइल को संशोधित करते हैं।

Step 2 - आप इन फ़ाइलों को स्टेजिंग क्षेत्र में जोड़ते हैं।

Step 3- आप चरणबद्ध क्षेत्र से फ़ाइलों को स्थानांतरित करने वाले प्रतिबद्ध संचालन करते हैं। पुश ऑपरेशन के बाद, यह परिवर्तन को स्थायी रूप से गिट रिपॉजिटरी में संग्रहीत करता है।

मान लीजिए कि आपने दो फ़ाइलों को संशोधित किया है, जिसका नाम "Sort.c" और "search.c" है और आप प्रत्येक ऑपरेशन के लिए दो अलग-अलग कमिट चाहते हैं। आप स्टेजिंग क्षेत्र में एक फ़ाइल जोड़ सकते हैं और कमिट कर सकते हैं। पहली प्रतिबद्ध के बाद, किसी अन्य फ़ाइल के लिए समान प्रक्रिया दोहराएं।

# First commit
[bash]$ git add sort.c # adds file to the staging area [bash]$ git commit –m “Added sort operation”

# Second commit
[bash]$ git add search.c # adds file to the staging area [bash]$ git commit –m “Added search operation”

धब्बे

बूँद के लिए खड़ा है Binary Large Obअस्वीकृत। फ़ाइल के प्रत्येक संस्करण को बूँद द्वारा दर्शाया जाता है। एक बूँद फ़ाइल डेटा रखती है, लेकिन फ़ाइल के बारे में कोई मेटाडेटा शामिल नहीं करती है। यह एक बाइनरी फ़ाइल है, और Git डेटाबेस में, इसे उस फ़ाइल के SHA1 हैश के रूप में नामित किया गया है। Git में, फ़ाइलों को नामों से संबोधित नहीं किया जाता है। सब कुछ सामग्री-संबोधित है।

पेड़

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

करता है

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

शाखाओं

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

टैग

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

क्लोन

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

खींचें

पुल ऑपरेशन एक दूरस्थ रिपॉजिटरी उदाहरण से स्थानीय एक में परिवर्तन की प्रतिलिपि बनाता है। पुल ऑपरेशन का उपयोग दो रिपॉजिटरी इंस्टेंस के बीच सिंक्रोनाइज़ेशन के लिए किया जाता है। यह सबवर्सन में अपडेट ऑपरेशन के समान है।

धक्का दें

पुश ऑपरेशन प्रतियां एक स्थानीय रिपॉजिटरी उदाहरण से दूरस्थ एक में बदल जाती हैं। इसका उपयोग परिवर्तन को स्थायी रूप से गिट रिपॉजिटरी में संग्रहीत करने के लिए किया जाता है। यह सबवर्सन में प्रतिबद्ध संचालन के समान है।

सिर

HEAD एक पॉइंटर है, जो हमेशा ब्रांच में लेटेस्ट कमेंट की ओर इशारा करता है। जब भी आप कोई प्रतिबद्ध करते हैं, तो HEAD को नवीनतम प्रतिबद्ध के साथ अद्यतन किया जाता है। शाखाओं के प्रमुखों में संग्रहीत किया जाता है.git/refs/heads/ निर्देशिका।

[CentOS]$ ls -1 .git/refs/heads/ master [CentOS]$ cat .git/refs/heads/master
570837e7d58fa4bccd86cb575d884502188b0c49

संशोधन

संशोधन स्रोत कोड के संस्करण का प्रतिनिधित्व करता है। Git में संशोधन कमिट द्वारा दर्शाए गए हैं। इन कमिटों द्वारा पहचान की जाती हैSHA1 सुरक्षित हैश।

यूआरएल

URL गिट रिपॉजिटरी के स्थान का प्रतिनिधित्व करता है। Git URL को कॉन्फिगर फाइल में स्टोर किया जाता है।

[tom@CentOS tom_repo]$ pwd /home/tom/tom_repo [tom@CentOS tom_repo]$ cat .git/config
[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
[remote "origin"]
url = [email protected]:project.git
fetch = +refs/heads/*:refs/remotes/origin/*

इससे पहले कि आप Git का उपयोग कर सकें, आपको कुछ बुनियादी कॉन्फ़िगरेशन परिवर्तन स्थापित करने और करने होंगे। नीचे उबंटू और सेंटोस लिनक्स पर गिट क्लाइंट स्थापित करने के चरण दिए गए हैं।

गिट क्लाइंट की स्थापना

यदि आप डेबियन बेस GNU / Linux वितरण का उपयोग कर रहे हैं, तो apt-get कमांड जरूरतमंदों को करेगा।

[ubuntu ~]$ sudo apt-get install git-core [sudo] password for ubuntu: [ubuntu ~]$ git --version
git version 1.8.1.2

और यदि आप RPM आधारित GNU / Linux वितरण का उपयोग कर रहे हैं, तो उपयोग करें yum जैसा आदेश दिया गया।

[CentOS ~]$
su -
Password:

[CentOS ~]# yum -y install git-core

[CentOS ~]# git --version
git version 1.7.1

गिट पर्यावरण को अनुकूलित करें

Git, git config टूल प्रदान करता है, जो आपको कॉन्फ़िगरेशन चर सेट करने की अनुमति देता है। Git सभी वैश्विक कॉन्फ़िगरेशन को संग्रहीत करता है.gitconfigफ़ाइल, जो आपके होम डायरेक्टरी में स्थित है। इन कॉन्फ़िगरेशन मानों को वैश्विक के रूप में सेट करने के लिए, जोड़ें--global विकल्प, और यदि आप छोड़ देते हैं --global विकल्प, तो आपके विन्यास वर्तमान गिट रिपॉजिटरी के लिए विशिष्ट हैं।

आप सिस्टम वाइड कॉन्फ़िगरेशन भी सेट कर सकते हैं। Git इन मूल्यों को संग्रहीत करता है/etc/gitconfigफ़ाइल, जिसमें सिस्टम पर प्रत्येक उपयोगकर्ता और रिपॉजिटरी के लिए कॉन्फ़िगरेशन शामिल है। इन मूल्यों को निर्धारित करने के लिए, आपके पास मूल अधिकार होना चाहिए और इसका उपयोग करना चाहिए--system विकल्प।

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

उपयोगकर्ता नाम सेट करना

इस जानकारी का उपयोग प्रत्येक कमिट के लिए Git द्वारा किया जाता है।

[jerry@CentOS project]$ git config --global user.name "Jerry Mouse"

ईमेल आईडी सेट करना

इस जानकारी का उपयोग प्रत्येक कमिट के लिए Git द्वारा किया जाता है।

[jerry@CentOS project]$ git config --global user.email "[email protected]"

खींचने के लिए मर्ज करने से बचें

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

jerry@CentOS project]$ git config --global branch.autosetuprebase always

रंग उजागर करना

निम्न आदेश कंसोल में Git के लिए रंग हाइलाइटिंग सक्षम करते हैं।

[jerry@CentOS project]$ git config --global color.ui true [jerry@CentOS project]$ git config --global color.status auto

[jerry@CentOS project]$ git config --global color.branch auto

डिफ़ॉल्ट संपादक सेट करना

डिफ़ॉल्ट रूप से, Git सिस्टम डिफॉल्ट एडिटर का उपयोग करता है, जो VISUAL या EDITOR पर्यावरण चर से लिया गया है। हम git config का उपयोग करके किसी भिन्न को कॉन्फ़िगर कर सकते हैं।

[jerry@CentOS project]$ git config --global core.editor vim

डिफ़ॉल्ट मर्ज उपकरण सेट करना

Git आपके कार्य ट्री में परस्पर विरोधी परिवर्तनों को एकीकृत करने के लिए एक डिफ़ॉल्ट मर्ज टूल प्रदान नहीं करता है। हम निम्नलिखित सेटिंग्स को सक्षम करके डिफ़ॉल्ट मर्ज टूल सेट कर सकते हैं।

[jerry@CentOS project]$ git config --global merge.tool vimdiff

लिस्टिंग सेटिंग्स

स्थानीय रिपॉजिटरी की अपनी Git सेटिंग्स को सत्यापित करने के लिए, का उपयोग करें git config –list जैसा कि नीचे दिया गया है।

[jerry@CentOS ~]$ git config --list

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

user.name=Jerry Mouse
[email protected]
push.default=nothing
branch.autosetuprebase=always
color.ui=true
color.status=auto
color.branch=auto
core.editor=vim
merge.tool=vimdiff

इस अध्याय में, हम Git के जीवन चक्र पर चर्चा करेंगे। बाद के अध्यायों में, हम प्रत्येक ऑपरेशन के लिए Git कमांड को कवर करेंगे।

सामान्य वर्कफ़्लो इस प्रकार है -

• आप एक प्रतिलिपि के रूप में गिट रिपॉजिटरी को क्लोन करते हैं।

• आप फ़ाइलों को जोड़कर / संपादित करके कार्य की प्रति संशोधित करते हैं।

• यदि आवश्यक हो, तो आप अन्य डेवलपर के परिवर्तनों को लेते हुए कार्य की प्रतिलिपि भी अपडेट करते हैं।

• आप प्रतिबद्ध होने से पहले परिवर्तनों की समीक्षा करते हैं।

• आप परिवर्तन करें। यदि सब कुछ ठीक है, तो आप रिपॉजिटरी में बदलावों को आगे बढ़ाते हैं।

• कमिट करने के बाद, अगर आपको एहसास होता है कि कुछ गलत है, तो आप आखिरी कमिट को सही करते हैं और रिपॉजिटरी में बदलाव को धक्का देते हैं।

नीचे दिखाया गया कार्य-प्रवाह का सचित्र प्रतिनिधित्व है।

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

नया उपयोगकर्ता बनाएँ

# add new group
[root@CentOS ~]# groupadd dev

# add new user
[root@CentOS ~]# useradd -G devs -d /home/gituser -m -s /bin/bash gituser

# change password
[root@CentOS ~]# passwd gituser

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

Changing password for user gituser.
New password:
Retype new password:
passwd: all authentication token updated successfully.

एक बेर रिपोजिटरी बनाएँ

आइए हम एक नए भंडार का उपयोग करके आरंभ करते हैं init उसके बाद कमांड --bareविकल्प। यह एक कार्यशील निर्देशिका के बिना भंडार को आरंभ करता है। सम्मेलन के द्वारा, नंगे भंडार का नाम दिया जाना चाहिए.git।

[gituser@CentOS ~]$ pwd /home/gituser [gituser@CentOS ~]$ mkdir project.git

[gituser@CentOS ~]$ cd project.git/ [gituser@CentOS project.git]$ ls

[gituser@CentOS project.git]$ git --bare init Initialized empty Git repository in /home/gituser-m/project.git/ [gituser@CentOS project.git]$ ls
branches config description HEAD hooks info objects refs

सार्वजनिक / निजी आरएसए कुंजी जोड़ी उत्पन्न करें

हमें एक Git सर्वर को कॉन्फ़िगर करने की प्रक्रिया से चलना चाहिए, ssh-keygen उपयोगिता सार्वजनिक / निजी आरएसए कुंजी जोड़ी उत्पन्न करती है, जिसका उपयोग हम उपयोगकर्ता प्रमाणीकरण के लिए करेंगे।

एक टर्मिनल खोलें और निम्नलिखित कमांड दर्ज करें और प्रत्येक इनपुट के लिए बस एंटर दबाएं। सफल होने के बाद, यह एक निर्माण करेगा.ssh घर निर्देशिका के अंदर निर्देशिका।

tom@CentOS ~]$ pwd /home/tom [tom@CentOS ~]$ ssh-keygen

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

Generating public/private rsa key pair.
Enter file in which to save the key (/home/tom/.ssh/id_rsa): Press Enter Only
Created directory '/home/tom/.ssh'.
Enter passphrase (empty for no passphrase): ---------------> Press Enter Only
Enter same passphrase again: ------------------------------> Press Enter Only
Your identification has been saved in /home/tom/.ssh/id_rsa.
Your public key has been saved in /home/tom/.ssh/id_rsa.pub.
The key fingerprint is:
df:93:8c:a1:b8:b7:67:69:3a:1f:65:e8:0e:e9:25:a1 tom@CentOS
The key's randomart image is:
+--[ RSA 2048]----+
| |
| |
| |
|
.
|
| Soo |
| o*B. |
| E = *.= |
| oo==. . |
| ..+Oo
|
+-----------------+

ssh-keygen ने दो कुंजी उत्पन्न की हैं, पहला निजी है (यानी, id_rsa) और दूसरा सार्वजनिक है (यानी, id_rsa.pub)।

Note: कभी भी अपनी निजी कुंजी दूसरों के साथ साझा न करें।

अधिकृत_की में कुंजी जोड़ना

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

टॉम ने सर्वर से अपनी सार्वजनिक कुंजी को जोड़ा ssh-copy-id नीचे दिए अनुसार कमांड -

[tom@CentOS ~]$ pwd /home/tom [tom@CentOS ~]$ ssh-copy-id -i ~/.ssh/id_rsa.pub [email protected]

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

[email protected]'s password:
Now try logging into the machine, with "ssh '[email protected]'", and check in:
.ssh/authorized_keys
to make sure we haven't added extra keys that you weren't expecting.

इसी तरह, जेरी ने ssh-copy-id कमांड का उपयोग करके सर्वर में अपनी सार्वजनिक कुंजी जोड़ी।

[jerry@CentOS ~]$ pwd /home/jerry [jerry@CentOS ~]$ ssh-copy-id -i ~/.ssh/id_rsa [email protected]

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

[email protected]'s password:
Now try logging into the machine, with "ssh '[email protected]'", and check in:
.ssh/authorized_keys
to make sure we haven't added extra keys that you weren't expecting.

रिपोजिटरी में परिवर्तन

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

Git init कमांड बनाता है .git हर बार जब यह कॉन्फ़िगरेशन पढ़ता है, तो संग्रह के बारे में मेटाडेटा को संग्रहीत करने के लिए निर्देशिका .git/config फ़ाइल।

टॉम एक नई निर्देशिका बनाता है, README फ़ाइल जोड़ता है, और प्रारंभिक बदलाव के रूप में अपना परिवर्तन करता है। प्रतिबद्ध होने के बाद, वह चलाकर प्रतिबद्ध संदेश की पुष्टि करता हैgit log आदेश।

[tom@CentOS ~]$ pwd /home/tom [tom@CentOS ~]$ mkdir tom_repo

[tom@CentOS ~]$ cd tom_repo/ [tom@CentOS tom_repo]$ git init
Initialized empty Git repository in /home/tom/tom_repo/.git/

[tom@CentOS tom_repo]$ echo 'TODO: Add contents for README' > README [tom@CentOS tom_repo]$ git status -s
?? README

[tom@CentOS tom_repo]$ git add . [tom@CentOS tom_repo]$ git status -s
A README

[tom@CentOS tom_repo]$ git commit -m 'Initial commit'

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

[master (root-commit) 19ae206] Initial commit
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 README

टॉम गेट लॉग कमांड को निष्पादित करके लॉग संदेश की जांच करता है।

[tom@CentOS tom_repo]$ git log

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 07:32:56 2013 +0530

Initial commit

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

Note- डिफ़ॉल्ट रूप से, Git केवल मिलान शाखाओं पर धकेलता है: स्थानीय शाखा में मौजूद प्रत्येक शाखा के लिए, दूरस्थ पक्ष को अद्यतन किया जाता है यदि उसी नाम वाली शाखा पहले से ही वहां मौजूद है। हमारे ट्यूटोरियल में, हर बार हम परिवर्तनों को धक्का देते हैंorigin master शाखा, अपनी आवश्यकता के अनुसार उपयुक्त शाखा नाम का उपयोग करें।

[tom@CentOS tom_repo]$ git remote add origin [email protected]:project.git [tom@CentOS tom_repo]$ git push origin master

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

Counting objects: 3, done.
Writing objects: 100% (3/3), 242 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To [email protected]:project.git
* [new branch]
master −> master

अब, परिवर्तन सफलतापूर्वक दूरस्थ रिपॉजिटरी के लिए प्रतिबद्ध हैं।

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

जेरी अपने घर निर्देशिका में एक नई निर्देशिका बनाता है और क्लोन ऑपरेशन करता है।

[jerry@CentOS ~]$ mkdir jerry_repo [jerry@CentOS ~]$ cd jerry_repo/

[jerry@CentOS jerry_repo]$ git clone [email protected]:project.git

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

Initialized empty Git repository in /home/jerry/jerry_repo/project/.git/
remote: Counting objects: 3, done.
Receiving objects: 100% (3/3), 241 bytes, done.
remote: Total 3 (delta 0), reused 0 (delta 0)

जेरी निर्देशिका को नए स्थानीय भंडार में बदलता है और अपनी निर्देशिका सामग्री को सूचीबद्ध करता है।

[jerry@CentOS jerry_repo]$ cd project/

[jerry@CentOS jerry_repo]$ ls
README

जेरी रिपॉजिटरी को क्लोन करता है और बुनियादी स्ट्रिंग ऑपरेशन को लागू करने का फैसला करता है। इसलिए वह string.c फाइल बनाता है। सामग्री जोड़ने के बाद, string.c

#include <stdio.h>

int my_strlen(char *s)
{
   char *p = s;

   while (*p)
      ++p;

   return (p - s);
}

int main(void)
{
   int i;
   char *s[] = 
   {
      "Git tutorials",
      "Tutorials Point"
   };

   for (i = 0; i < 2; ++i)
      
   printf("string lenght of %s = %d\n", s[i], my_strlen(s[i]));

   return 0;
}

उन्होंने अपने कोड का संकलन और परीक्षण किया और सब कुछ ठीक चल रहा है। अब, वह इन परिवर्तनों को भंडार में सुरक्षित रूप से जोड़ सकता है।

गेट ऐड ऑपरेशन स्टेजिंग क्षेत्र में फ़ाइल जोड़ता है।

[jerry@CentOS project]$ git status -s
?? string
?? string.c

[jerry@CentOS project]$ git add string.c

फ़ाइल नामों से पहले Git एक प्रश्न चिह्न दिखा रहा है। जाहिर है, ये फाइलें Git का हिस्सा नहीं हैं, और यही वजह है कि Git को नहीं पता कि इन फाइलों का क्या करना है। इसीलिए, फ़ाइल नाम से पहले Git एक प्रश्न चिह्न दिखा रहा है।

जेरी ने फाइल को स्टैश एरिया में जोड़ा है, git स्टेटस कमांड स्टेजिंग एरिया में मौजूद फाइल को दिखाएगा।

[jerry@CentOS project]$ git status -s
A string.c
?? string

परिवर्तनों को करने के लिए, उन्होंने git कमिट कमांड का उपयोग किया, उसके बाद -m विकल्प। अगर हम विकल्प छोड़ देते हैं। Git एक टेक्स्ट एडिटर खोलेगा जहाँ हम मल्टीलाइन कमिट मैसेज लिख सकते हैं।

[jerry@CentOS project]$ git commit -m 'Implemented my_strlen function'

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

[master cbe1249] Implemented my_strlen function
1 files changed, 24 insertions(+), 0 deletions(-)
create mode 100644 string.c

लॉग विवरण देखने के लिए प्रतिबद्ध होने के बाद, वह गिट लॉग कमांड चलाता है। यह सभी कमिट्स की जानकारी अपनी कमिट आईडी, कमेटी ऑथर, कमिट डेट और के साथ प्रदर्शित करेगाSHA-1 हैश ऑफ कमिट।

[jerry@CentOS project]$ git log

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

commit cbe1249b140dad24b2c35b15cc7e26a6f02d2277
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:05:26 2013 +0530

Implemented my_strlen function


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 07:32:56 2013 +0530

Initial commit

प्रतिबद्ध विवरण देखने के बाद, जेरी को पता चलता है कि स्ट्रिंग की लंबाई ऋणात्मक नहीं हो सकती है, इसीलिए वह my_lenlen फ़ंक्शन के रिटर्न प्रकार को बदलने का फैसला करता है।

जेरी का उपयोग करता है git log लॉग विवरण देखने के लिए कमांड।

[jerry@CentOS project]$ git log

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

commit cbe1249b140dad24b2c35b15cc7e26a6f02d2277
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:05:26 2013 +0530

Implemented my_strlen function

जेरी का उपयोग करता है git showप्रतिबद्ध विवरण देखने की आज्ञा। गिट शो कमांड लेता हैSHA-1 एक पैरामीटर के रूप में आईडी करें।

[jerry@CentOS project]$ git show cbe1249b140dad24b2c35b15cc7e26a6f02d2277

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

commit cbe1249b140dad24b2c35b15cc7e26a6f02d2277
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:05:26 2013 +0530

Implemented my_strlen function


diff --git a/string.c b/string.c
new file mode 100644
index 0000000..187afb9
--- /dev/null
+++ b/string.c
@@ -0,0 +1,24 @@
+#include <stdio.h>
+
+int my_strlen(char *s)
+{
   +
   char *p = s;
   +
   +
   while (*p)
   + ++p;
   + return (p -s );
   +
}
+

वह फंक्शन के रिटर्न प्रकार को int से size_t में बदलता है। कोड का परीक्षण करने के बाद, वह चलाकर अपने परिवर्तनों की समीक्षा करता हैgit diff आदेश।

[jerry@CentOS project]$ git diff

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

diff --git a/string.c b/string.c
index 187afb9..7da2992 100644
--- a/string.c
+++ b/string.c
@@ -1,6 +1,6 @@
#include <stdio.h>

-int my_strlen(char *s)
+size_t my_strlen(char *s)
{
   char *p = s;
   @@ -18,7 +18,7 @@ int main(void)
};
for (i = 0; i < 2; ++i)
{
   - printf("string lenght of %s = %d\n", s[i], my_strlen(s[i]));
   + printf("string lenght of %s = %lu\n", s[i], my_strlen(s[i]));
   return 0;
}

गिट भिन्न शो '+' लाइनों से पहले साइन इन करें, जो नए जोड़े गए हैं और '−' हटाए गए लाइनों के लिए।

जेरी ने पहले ही बदलाव किए हैं और वह अपनी आखिरी प्रतिबद्धता को सुधारना चाहता है। इस मामले में,git amendऑपरेशन में मदद मिलेगी। संशोधन ऑपरेशन आपकी प्रतिबद्ध संदेश सहित अंतिम प्रतिबद्ध को बदलता है; यह एक नई कमिट आईडी बनाता है।

ऑपरेशन में संशोधन करने से पहले, वह कमिट लॉग की जांच करता है।

[jerry@CentOS project]$ git log

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

commit cbe1249b140dad24b2c35b15cc7e26a6f02d2277
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:05:26 2013 +0530

Implemented my_strlen function


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 07:32:56 2013 +0530

Initial commit

जेरी ने नए बदलाव किए - संशोधन संचालन और प्रतिबद्ध लॉग को देखा।

[jerry@CentOS project]$ git status -s M string.c ?? string [jerry@CentOS project]$ git add string.c

[jerry@CentOS project]$ git status -s M string.c ?? string [jerry@CentOS project]$ git commit --amend -m 'Changed return type of my_strlen to size_t'
[master d1e19d3] Changed return type of my_strlen to size_t
1 files changed, 24 insertions(+), 0 deletions(-)
create mode 100644 string.c

अब, जीआईटी लॉग नई कमिट आईडी के साथ नया संदेश दिखाएगा -

[jerry@CentOS project]$ git log

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 07:32:56 2013 +0530

Initial commit

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

वह प्रतिबद्ध विवरण देखने के लिए git लॉग कमांड निष्पादित करता है।

[jerry@CentOS project]$ git log

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा:

commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t

पुश ऑपरेशन से पहले, वह अपने परिवर्तनों की समीक्षा करना चाहता है, इसलिए वह इसका उपयोग करता है git show उसके बदलावों की समीक्षा करने की आज्ञा।

[jerry@CentOS project]$ git show d1e19d316224cddc437e3ed34ec3c931ad803958

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा:

commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t

diff --git a/string.c b/string.c
new file mode 100644
index 0000000..7da2992
--- /dev/null
+++ b/string.c
@@ -0,0 +1,24 @@
+#include <stdio.h>
+
+size_t my_strlen(char *s)
+
{
   +
   char *p = s;
   +
   +
   while (*p)
   + ++p;
   + return (p -s );
   +
}
+
+int main(void)
+
{
   + int i;
   + char *s[] = 
   {
      + "Git tutorials",
      + "Tutorials Point"
      +
   };
   +
   +
   +
   for (i = 0; i < 2; ++i)
   printf("string lenght of %s = %lu\n", s[i], my_strlen(s[i]));
   +
   +
   return 0;
   +
}

जेरी अपने परिवर्तनों से खुश है और वह अपने परिवर्तनों को आगे बढ़ाने के लिए तैयार है।

[jerry@CentOS project]$ git push origin master

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा:

Counting objects: 4, done.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 517 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To [email protected]:project.git
19ae206..d1e19d3 master −> master

जेरी के परिवर्तनों को सफलतापूर्वक भंडार में धकेल दिया गया है; अब अन्य डेवलपर्स क्लोन या अपडेट ऑपरेशन करके अपने बदलाव देख सकते हैं।

मौजूदा फ़ंक्शन को संशोधित करें

टॉम क्लोन ऑपरेशन करता है और एक नया फ़ाइल string.c पाता है। वह जानना चाहता है कि किसने इस फाइल को रिपॉजिटरी में जोड़ा और किस उद्देश्य से, इसलिए, वह निष्पादित करता हैgit log आदेश।

[tom@CentOS ~]$ git clone [email protected]:project.git

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

Initialized empty Git repository in /home/tom/project/.git/
remote: Counting objects: 6, done.
remote: Compressing objects: 100% (4/4), done.
Receiving objects: 100% (6/6), 726 bytes, done.
remote: Total 6 (delta 0), reused 0 (delta 0)

क्लोन ऑपरेशन वर्तमान कार्यशील निर्देशिका के अंदर एक नई निर्देशिका बनाएगा। वह निर्देशिका को नई बनाई गई निर्देशिका में बदलता है और निष्पादित करता हैgit log आदेश।

[tom@CentOS ~]$ cd project/

[tom@CentOS project]$ git log

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 07:32:56 2013 +0530

Initial commit

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

[tom@CentOS project]$ git diff

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

diff --git a/string.c b/string.c
index 7da2992..32489eb 100644
--- a/string.c
+++ b/string.c
@@ -1,8 +1,8 @@
#include <stdio.h>
-size_t my_strlen(char *s)
+size_t my_strlen(const char *s)
{
   - char *p = s;
   + const char *p = s;
   while (*p)
   ++p;
}

परीक्षण के बाद, वह अपना परिवर्तन करता है।

[tom@CentOS project]$ git status -s M string.c ?? string [tom@CentOS project]$ git add string.c

[tom@CentOS project]$ git commit -m 'Changed char pointer to const char pointer' [master cea2c00] Changed char pointer to const char pointer 1 files changed, 2 insertions(+), 2 deletions(-) [tom@CentOS project]$ git log

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

commit cea2c000f53ba99508c5959e3e12fff493b
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 08:32:07 2013 +0530

Changed char pointer to const char pointer


commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 07:32:56 2013 +0530
Initial commit

टॉम अपने बदलावों को आगे बढ़ाने के लिए git पुश कमांड का उपयोग करता है।

[tom@CentOS project]$ git push origin master

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

Counting objects: 5, done.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 336 bytes, done.
Total 3 (delta 1), reused 0 (delta 0)
To [email protected]:project.git
d1e19d3..cea2c00 master −> master

नया फ़ंक्शन जोड़ें

इस बीच, जैरी को लागू करने का फैसला किया string compareकार्यक्षमता। इसलिए वह string.c को संशोधित करता है। संशोधन के बाद, फ़ाइल इस प्रकार है -

[jerry@CentOS project]$ git diff

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

index 7da2992..bc864ed 100644
--- a/string.c
+++ b/string.c
30Git Tutorials
@@ -9,9 +9,20 @@ size_t my_strlen(char *s)
return (p -s );
}
+char *my_strcpy(char *t, char *s)
+
{
   +
   char *p = t;
   +
   + while (*t++ = *s++)
   + ;
   +
   +
   return p;
   +
}
+
int main(void)
{
   int i; 
   +
   char p1[32];
   char *s[] = 
   {
      "Git tutorials",
      "Tutorials Point"
      @@ -20,5 +31,7 @@ int main(void)
      for (i = 0; i < 2; ++i)
      printf("string lenght of %s = %lu\n", s[i], my_strlen(s[i]));
      +
      printf("%s\n", my_strcpy(p1, "Hello, World !!!"));
      +
      return 0;
   }
}

परीक्षण के बाद, वह अपने परिवर्तन को आगे बढ़ाने के लिए तैयार है।

[jerry@CentOS project]$ git status -s M string.c ?? string [jerry@CentOS project]$ git add string.c

[jerry@CentOS project]$ git commit -m "Added my_strcpy function"
[master e944e5a] Added my_strcpy function
1 files changed, 13 insertions(+), 0 deletions(-)

पुश ऑपरेशन से पहले, वह लॉग संदेशों को देखकर प्रतिबद्ध करता है।

[jerry@CentOS project]$ git log

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

commit e944e5aab74b26e7447d3281b225309e4e59efcd
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:41:42 2013 +0530

Added my_strcpy function


commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 07:32:56 2013 +0530

Initial commit

जेरी बदलावों से खुश है और वह अपने बदलावों को आगे बढ़ाना चाहता है।

[jerry@CentOS project]$ git push origin master

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

To [email protected]:project.git
! [rejected]
master −> master (non-fast-forward)
error: failed to push some refs to '[email protected]:project.git'
To prevent you from losing history, non-fast-forward updates were rejected
Merge the remote changes before pushing again. See the 'Note about
fast-forwards' section of 'git push --help' for details.

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

नवीनतम परिवर्तन लाएं

जेरी रिमोट के साथ अपने स्थानीय भंडार को सिंक्रनाइज़ करने के लिए गिट पुल कमांड को निष्पादित करता है।

[jerry@CentOS project]$ git pull

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

remote: Counting objects: 5, done.
remote: Compressing objects: 100% (3/3), done.
remote: Total 3 (delta 1), reused 0 (delta 0)
Unpacking objects: 100% (3/3), done.
From git.server.com:project
d1e19d3..cea2c00 master −> origin/master
First, rewinding head to replay your work on top of it...
Applying: Added my_strcpy function

पुल ऑपरेशन के बाद, जैरी लॉग संदेशों की जाँच करता है और टॉम की प्रतिबद्ध आईडी के विवरण का पता लगाता है cea2c000f53ba99508c5959e3e12fff493ba6f69

[jerry@CentOS project]$ git log

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

commit e86f0621c2a3f68190bba633a9fe6c57c94f8e4f
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:41:42 2013 +0530

Added my_strcpy function


commit cea2c000f53ba99508c5959e3e12fff493ba6f69
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 08:32:07 2013 +0530

Changed char pointer to const char pointer


commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 07:32:56 2013 +0530
Initial commit

अब, जैरी का स्थानीय भंडार दूरस्थ भंडार के साथ पूरी तरह से सिंक्रनाइज़ है। इसलिए वह अपने परिवर्तनों को सुरक्षित रूप से आगे बढ़ा सकता है।

[jerry@CentOS project]$ git push origin master

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

Counting objects: 5, done.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 455 bytes, done.
Total 3 (delta 1), reused 0 (delta 0)
To [email protected]:project.git
cea2c00..e86f062 master −> master

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

गिट में, स्टैश ऑपरेशन आपकी संशोधित ट्रैक की गई फ़ाइलों को ले जाता है, चरणों को बदलता है, और उन्हें अधूरे परिवर्तनों के ढेर पर बचाता है जिन्हें आप किसी भी समय पुन: लागू कर सकते हैं।

[jerry@CentOS project]$ git status -s
M string.c
?? string

अब, आप ग्राहक वृद्धि के लिए शाखाओं को स्विच करना चाहते हैं, लेकिन आप अभी तक जो काम कर रहे हैं वह करना नहीं चाहते हैं; इसलिए आप परिवर्तनों को रोकेंगे। अपने स्टैक पर एक नया स्टेश पुश करने के लिए, चलाएँgit stash आदेश।

[jerry@CentOS project]$ git stash
Saved working directory and index state WIP on master: e86f062 Added my_strcpy function
HEAD is now at e86f062 Added my_strcpy function

अब, आपकी कार्यशील निर्देशिका साफ है और सभी परिवर्तन एक स्टैक पर सहेजे गए हैं। आइए हम इसे सत्यापित करते हैंgit status आदेश।

[jerry@CentOS project]$ git status -s
?? string

अब आप सुरक्षित रूप से शाखा को स्विच कर सकते हैं और कहीं और काम कर सकते हैं। हम का उपयोग करके stashed परिवर्तनों की एक सूची देख सकते हैंgit stash list आदेश।

[jerry@CentOS project]$ git stash list
stash@{0}: WIP on master: e86f062 Added my_strcpy function

मान लीजिए कि आपने ग्राहक वृद्धि का समाधान कर लिया है और आप अपने नए फीचर पर वापस आ गए हैं, जो आपके आधे किए गए कोड की तलाश में है, बस निष्पादित करें git stash pop कमांड, स्टैक से परिवर्तनों को हटाने और उन्हें वर्तमान कार्यशील निर्देशिका में रखने के लिए।

[jerry@CentOS project]$ git status -s ?? string [jerry@CentOS project]$ git stash pop

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा:

# On branch master
# Changed but not updated:
# (use "git add ..." to update what will be committed)
# (use "git checkout -- ..." to discard changes in working directory)
#
#
modified: string.c
#
# Untracked files:
# (use "git add ..." to include in what will be committed)
#
#
string
no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (36f79dfedae4ac20e2e8558830154bd6315e72d4)

[jerry@CentOS project]$ git status -s
M string.c
?? string

जैसा कि नाम से पता चलता है, चाल ऑपरेशन एक निर्देशिका या एक फ़ाइल को एक स्थान से दूसरे स्थान पर ले जाता है। टॉम स्रोत कोड को स्थानांतरित करने का निर्णय लेता हैsrcनिर्देशिका। संशोधित निर्देशिका संरचना निम्नानुसार दिखाई देगी -

[tom@CentOS project]$ pwd
/home/tom/project

[tom@CentOS project]$ ls README string string.c [tom@CentOS project]$ mkdir src

[tom@CentOS project]$ git mv string.c src/ [tom@CentOS project]$ git status -s
R string.c −> src/string.c
?? string

इन परिवर्तनों को स्थायी बनाने के लिए, हमें संशोधित निर्देशिका संरचना को दूरस्थ रिपॉजिटरी में धकेलना होगा ताकि अन्य डेवलपर्स इसे देख सकें।

[tom@CentOS project]$ git commit -m "Modified directory structure" [master 7d9ea97] Modified directory structure 1 files changed, 0 insertions(+), 0 deletions(-) rename string.c => src/string.c (100%) [tom@CentOS project]$ git push origin master
Counting objects: 4, done.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 320 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To [email protected]:project.git
e86f062..7d9ea97 master −> master

जेरी के स्थानीय भंडार में, पुल संचालन से पहले, यह पुरानी निर्देशिका संरचना दिखाएगा।

[jerry@CentOS project]$ pwd /home/jerry/jerry_repo/project [jerry@CentOS project]$ ls
README string string.c

लेकिन पुल ऑपरेशन के बाद, निर्देशिका संरचना अपडेट हो जाएगी। अब, जेरी देख सकते हैंsrc निर्देशिका और उस निर्देशिका के अंदर मौजूद फ़ाइल।

[jerry@CentOS project]$ git pull remote: Counting objects: 4, done. remote: Compressing objects: 100% (2/2), done. remote: Total 3 (delta 0), reused 0 (delta 0) Unpacking objects: 100% (3/3), done. From git.server.com:project e86f062..7d9ea97 master −> origin/master First, rewinding head to replay your work on top of it... Fast-forwarded master to 7d9ea97683da90bcdb87c28ec9b4f64160673c8a. [jerry@CentOS project]$ ls
README src string

[jerry@CentOS project]$ ls src/
string.c

अब तक, टॉम और जेरी दोनों अपने प्रोजेक्ट को संकलित करने के लिए मैनुअल कमांड का उपयोग कर रहे थे। अब, जैरी ने अपनी परियोजना के लिए मेकफिल बनाने का फैसला किया और "string.c" फ़ाइल को एक उचित नाम भी दिया।

[jerry@CentOS project]$ pwd
/home/jerry/jerry_repo/project

[jerry@CentOS project]$ ls README src [jerry@CentOS project]$ cd src/

[jerry@CentOS src]$ git add Makefile [jerry@CentOS src]$ git mv string.c string_operations.c

[jerry@CentOS src]$ git status -s
A Makefile
R string.c −> string_operations.c

गिट दिखा रहा है R फ़ाइल नाम से पहले यह इंगित करने के लिए कि फ़ाइल का नाम बदल दिया गया है।

प्रतिबद्ध संचालन के लिए, जेरी ने -a ध्वज का उपयोग किया, जिससे गिट प्रतिबद्ध स्वचालित रूप से संशोधित फ़ाइलों का पता लगाता है।

[jerry@CentOS src]$ git commit -a -m 'Added Makefile and renamed strings.c to
string_operations.c '

[master 94f7b26] Added Makefile and renamed strings.c to string_operations.c
1 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 src/Makefile
rename src/{string.c => string_operations.c} (100%)

प्रतिबद्ध होने के बाद, वह अपने परिवर्तनों को भंडार में धकेल देता है।

[jerry@CentOS src]$ git push origin master

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

Counting objects: 6, done.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (4/4), 396 bytes, done.
Total 4 (delta 0), reused 0 (delta 0)
To [email protected]:project.git
7d9ea97..94f7b26 master −> master

अब, अन्य डेवलपर अपने स्थानीय भंडार को अपडेट करके इन संशोधनों को देख सकते हैं।

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

[tom@CentOS src]$ pwd
/home/tom/project/src

[tom@CentOS src]$ ls Makefile string_operations string_operations.c [tom@CentOS src]$ file string_operations
string_operations: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses
shared libs), for GNU/Linux 2.6.18, not stripped

[tom@CentOS src]$ git log
commit 29af9d45947dc044e33d69b9141d8d2dad37cc62
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 10:16:25 2013 +0530

Added compiled binary

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

[tom@CentOS src]$ ls
Makefile string_operations string_operations.c

[tom@CentOS src]$ git rm string_operations rm 'src/string_operations' [tom@CentOS src]$ git commit -a -m "Removed executable binary"

[master 5776472] Removed executable binary
1 files changed, 0 insertions(+), 0 deletions(-)
delete mode 100755 src/string_operations

प्रतिबद्ध होने के बाद, वह अपने परिवर्तनों को भंडार में धकेल देता है।

[tom@CentOS src]$ git push origin master

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

Counting objects: 5, done.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 310 bytes, done.
Total 3 (delta 1), reused 0 (delta 0)
To [email protected]:project.git
29af9d4..5776472 master −> master

गलती करना मानव का स्वभाव है। इसलिए हर वीसीएस एक निश्चित बिंदु तक गलतियों को ठीक करने की सुविधा प्रदान करता है। Git एक सुविधा प्रदान करता है जिसका उपयोग हम स्थानीय रिपॉजिटरी में किए गए संशोधनों को पूर्ववत करने के लिए कर सकते हैं।

मान लीजिए कि उपयोगकर्ता गलती से अपने स्थानीय भंडार में कुछ बदलाव करता है और फिर इन परिवर्तनों को पूर्ववत करना चाहता है। ऐसे मामलों में,revert ऑपरेशन एक महत्वपूर्ण भूमिका निभाता है।

अनवांटेड परिवर्तन वापस करें

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

[jerry@CentOS src]$ pwd
/home/jerry/jerry_repo/project/src

[jerry@CentOS src]$ git status -s M string_operations.c [jerry@CentOS src]$ git checkout string_operations.c

[jerry@CentOS src]$ git status –s

इसके अलावा, हम इसका उपयोग कर सकते हैं git checkoutस्थानीय रिपॉजिटरी से हटाई गई फ़ाइल प्राप्त करने के लिए कमांड। मान लें कि टॉम ने स्थानीय रिपॉजिटरी से एक फ़ाइल को हटा दिया है और हम इस फ़ाइल को वापस चाहते हैं। हम एक ही कमांड का उपयोग करके इसे प्राप्त कर सकते हैं।

[tom@CentOS src]$ pwd
/home/tom/top_repo/project/src

[tom@CentOS src]$ ls -1 Makefile string_operations.c [tom@CentOS src]$ rm string_operations.c

[tom@CentOS src]$ ls -1 Makefile [tom@CentOS src]$ git status -s
D string_operations.c

Git पत्र दिखा रहा है Dफ़ाइल नाम से पहले। यह इंगित करता है कि फ़ाइल को स्थानीय रिपॉजिटरी से हटा दिया गया है।

[tom@CentOS src]$ git checkout string_operations.c [tom@CentOS src]$ ls -1
Makefile
string_operations.c

[tom@CentOS src]$ git status -s

Note - हम इन सभी ऑपरेशनों को कमिट करने से पहले कर सकते हैं।

स्टेजिंग एरिया से बदलाव निकालें

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

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

मान लें कि टॉम अपने स्थानीय भंडार से एक फ़ाइल को संशोधित करता है। यदि हम इस फ़ाइल की स्थिति देखते हैं, तो यह दिखाएगा कि फ़ाइल को संशोधित किया गया था, लेकिन स्टेजिंग क्षेत्र में नहीं जोड़ा गया था।

tom@CentOS src]$ pwd
/home/tom/top_repo/project/src
# Unmodified file

[tom@CentOS src]$ git status -s # Modify file and view it’s status. [tom@CentOS src]$ git status -s
M string_operations.c

[tom@CentOS src]$ git add string_operations.c

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

[tom@CentOS src]$ git checkout HEAD -- string_operations.c

[tom@CentOS src]$ git status -s

जीआईटी रीसेट के साथ हेड पॉइंटर को स्थानांतरित करें

कुछ परिवर्तन करने के बाद, आप इन परिवर्तनों को दूर करने का निर्णय ले सकते हैं। Git रीसेट कमांड का उपयोग परिवर्तनों को रीसेट करने या वापस लाने के लिए किया जाता है। हम तीन अलग-अलग प्रकार के रीसेट ऑपरेशन कर सकते हैं।

नीचे आरेख Git रीसेट कमांड के सचित्र प्रतिनिधित्व को दर्शाता है।

मुलायम

प्रत्येक शाखा में एक HEAD पॉइंटर होता है, जो नवीनतम प्रतिबद्ध की ओर इशारा करता है। अगर हम Git रीसेट कमांड का इस्तेमाल कमिट आईडी के बाद --soft ऑप्शन के साथ करते हैं, तो यह बिना कुछ नष्ट किए ही HEAD पॉइंटर को रीसेट कर देगा।

.git/refs/heads/masterफ़ाइल HEAD पॉइंटर के कमिट आईडी को स्टोर करता है। हम इसका उपयोग करके सत्यापित कर सकते हैंgit log -1 आदेश।

[jerry@CentOS project]$ cat .git/refs/heads/master
577647211ed44fe2ae479427a0668a4f12ed71a1

अब, नवीनतम कमिट आईडी देखें, जो कि उपरोक्त कमिट आईडी से मेल खाएगी।

[jerry@CentOS project]$ git log -2

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

commit 577647211ed44fe2ae479427a0668a4f12ed71a1
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 10:21:20 2013 +0530

Removed executable binary


commit 29af9d45947dc044e33d69b9141d8d2dad37cc62
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 10:16:25 2013 +0530

Added compiled binary

आइए हम HEAD पॉइंटर को रीसेट करें।

[jerry@CentOS project]$ git reset --soft HEAD~

अब, हम बस HEAD पॉइंटर को एक स्थिति में वापस लाते हैं। हमें की सामग्री की जाँच करें.git/refs/heads/master file।

[jerry@CentOS project]$ cat .git/refs/heads/master
29af9d45947dc044e33d69b9141d8d2dad37cc62

फ़ाइल से कमिट आईडी बदल दी गई है, अब इसे कमिट मैसेज देखकर सत्यापित करें।

jerry@CentOS project]$ git log -2

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

commit 29af9d45947dc044e33d69b9141d8d2dad37cc62
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 10:16:25 2013 +0530

Added compiled binary


commit 94f7b26005f856f1a1b733ad438e97a0cd509c1a
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 10:08:01 2013 +0530

Added Makefile and renamed strings.c to string_operations.c

मिश्रित

Git रीसेट के साथ --mixed विकल्प उन स्टेजिंग क्षेत्र से उन परिवर्तनों को हटा देता है जो अभी तक प्रतिबद्ध नहीं हैं। यह केवल स्टेजिंग क्षेत्र से हुए परिवर्तनों को प्रदर्शित करता है। फ़ाइल की कार्य प्रतिलिपि में किए गए वास्तविक परिवर्तन अप्रभावित हैं। डिफ़ॉल्ट Git रीसेट, git रीसेट - मिश्रित के बराबर है।

कठिन

यदि आप Git रीसेट कमांड के साथ -हार्ड विकल्प का उपयोग करते हैं, तो यह स्टेजिंग क्षेत्र को साफ कर देगा; यह HEAD पॉइंटर को विशिष्ट प्रतिबद्ध ID की नवीनतम स्थिति में रीसेट कर देगा और स्थानीय फ़ाइल परिवर्तनों को भी हटा देगा।

आइए हम प्रतिबद्ध आईडी की जांच करते हैं।

[jerry@CentOS src]$ pwd /home/jerry/jerry_repo/project/src [jerry@CentOS src]$ git log -1

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

commit 577647211ed44fe2ae479427a0668a4f12ed71a1
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 10:21:20 2013 +0530

Removed executable binary

जेरी ने फ़ाइल के प्रारंभ में एकल-पंक्ति टिप्पणी जोड़कर एक फ़ाइल को संशोधित किया।

[jerry@CentOS src]$ head -2 string_operations.c
/* This line be removed by git reset operation */
#include <stdio.h>

उन्होंने git स्टेटस कमांड का उपयोग करके इसे सत्यापित किया।

[jerry@CentOS src]$ git status -s
M string_operations.c

जैरी संशोधित फ़ाइल को स्टेजिंग क्षेत्र में जोड़ता है और इसे गिट स्थिति कमांड के साथ सत्यापित करता है।

[jerry@CentOS src]$ git add string_operations.c [jerry@CentOS src]$ git status

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
#
modified: string_operations.c
#

Git स्टेटस दिखा रहा है कि फाइल स्टेजिंग एरिया में मौजूद है। अब, हार्ड विकल्प के साथ HEAD रीसेट करें।

[jerry@CentOS src]$ git reset --hard 577647211ed44fe2ae479427a0668a4f12ed71a1

HEAD is now at 5776472 Removed executable binary

Git रीसेट कमांड सफल हुआ, जो फ़ाइल को स्टेजिंग क्षेत्र से वापस कर देगा और साथ ही फ़ाइल में किए गए किसी भी स्थानीय परिवर्तन को हटा देगा।

[jerry@CentOS src]$ git status -s

Git स्टेटस दिखा रहा है कि फाइल स्टेजिंग एरिया से वापस आ गई है।

[jerry@CentOS src]$ head -2 string_operations.c
#include <stdio.h>

हेड कमांड यह भी दर्शाता है कि रीसेट ऑपरेशन ने स्थानीय परिवर्तनों को भी हटा दिया है।

टैग ऑपरेशन, रिपॉजिटरी में एक विशिष्ट संस्करण को सार्थक नाम देने की अनुमति देता है। मान लीजिए कि टॉम और जेरी अपने प्रोजेक्ट कोड को टैग करने का निर्णय लेते हैं ताकि वे बाद में इसे आसानी से एक्सेस कर सकें।

टैग बनाएँ

हमें वर्तमान HEAD का उपयोग करके टैग करें git tagआदेश। टॉम -a विकल्प के साथ एक टैग नाम प्रदान करता है और -m विकल्प के साथ एक टैग संदेश प्रदान करता है।

tom@CentOS project]$ pwd
/home/tom/top_repo/project

[tom@CentOS project]$ git tag -a 'Release_1_0' -m 'Tagged basic string operation code' HEAD

यदि आप किसी विशेष कमिटमेंट को टैग करना चाहते हैं, तो HEAD पॉइंटर के बजाय उपयुक्त COMMIT ID का उपयोग करें। टॉम रिमोट रिपॉजिटरी में टैग को पुश करने के लिए निम्न कमांड का उपयोग करता है।

[tom@CentOS project]$ git push origin tag Release_1_0

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

Counting objects: 1, done.
Writing objects: 100% (1/1), 183 bytes, done.
Total 1 (delta 0), reused 0 (delta 0)
To [email protected]:project.git
* [new tag]
Release_1_0 −> Release_1_0

टैग देखें

टॉम ने टैग बनाए। अब, जैरी -L विकल्प के साथ Git टैग कमांड का उपयोग करके सभी उपलब्ध टैग देख सकता है।

[jerry@CentOS src]$ pwd /home/jerry/jerry_repo/project/src [jerry@CentOS src]$ git pull
remote: Counting objects: 1, done.
remote: Total 1 (delta 0), reused 0 (delta 0)
Unpacking objects: 100% (1/1), done.
From git.server.com:project
* [new tag]
Release_1_0 −> Release_1_0
Current branch master is up to date.

[jerry@CentOS src]$ git tag -l
Release_1_0

जैरी टैग के बारे में अधिक जानकारी देखने के लिए अपने टैग नाम के बाद Git शो कमांड का उपयोग करता है।

[jerry@CentOS src]$ git show Release_1_0

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

tag Release_1_0
Tagger: Tom Cat <[email protected]>
Date: Wed Sep 11 13:45:54 2013 +0530

Tagged basic string operation code


commit 577647211ed44fe2ae479427a0668a4f12ed71a1
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 10:21:20 2013 +0530

Removed executable binary

diff --git a/src/string_operations b/src/string_operations
deleted file mode 100755
index 654004b..0000000
Binary files a/src/string_operations and /dev/null differ

टैग हटाएं

टॉम स्थानीय और साथ ही दूरस्थ भंडार से टैग हटाने के लिए निम्न आदेश का उपयोग करता है।

[tom@CentOS project]$ git tag Release_1_0 [tom@CentOS project]$ git tag -d Release_1_0
Deleted tag 'Release_1_0' (was 0f81ff4)
# Remove tag from remote repository.

[tom@CentOS project]$ git push origin :Release_1_0
To [email protected]:project.git
- [deleted]
Release_1_0

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

जेरी अपने प्रोजेक्ट के लिए स्ट्रैट फंक्शन को लागू करता है। जैरी अपने कोड का एक रास्ता बना सकता है और टॉम को भेज सकता है। फिर, वह प्राप्त पैच को अपने कोड पर लागू कर सकता है।

जेरी गिट का उपयोग करता है format-patchनवीनतम प्रतिबद्ध के लिए एक पैच बनाने के लिए आदेश। यदि आप एक विशिष्ट प्रतिबद्ध के लिए एक पैच बनाना चाहते हैं, तो उपयोग करेंCOMMIT_ID प्रारूप-पैच कमांड के साथ।

[jerry@CentOS project]$ pwd
/home/jerry/jerry_repo/project/src

[jerry@CentOS src]$ git status -s M string_operations.c ?? string_operations [jerry@CentOS src]$ git add string_operations.c

[jerry@CentOS src]$ git commit -m "Added my_strcat function" [master b4c7f09] Added my_strcat function 1 files changed, 13 insertions(+), 0 deletions(-) [jerry@CentOS src]$ git format-patch -1
0001-Added-my_strcat-function.patch

उपरोक्त कमांड बनाता है .patchवर्तमान कार्यशील निर्देशिका के अंदर फाइलें। टॉम अपनी फ़ाइलों को संशोधित करने के लिए इस पैच का उपयोग कर सकता है। पैच लगाने के लिए Git दो कमांड प्रदान करता हैgit amतथा git apply, क्रमशः। Git apply जबकि बनाए बिना स्थानीय फ़ाइलों को संशोधित करता है git am फ़ाइल को संशोधित करता है और साथ ही प्रतिबद्ध बनाता है।

पैच लगाने और कमिट करने के लिए, निम्न कमांड का उपयोग करें -

[tom@CentOS src]$ pwd /home/tom/top_repo/project/src [tom@CentOS src]$ git diff

[tom@CentOS src]$ git status –s [tom@CentOS src]$ git apply 0001-Added-my_strcat-function.patch

[tom@CentOS src]$ git status -s
M string_operations.c
?? 0001-Added-my_strcat-function.patch

पैच सफलतापूर्वक लागू हो जाता है, अब हम संशोधनों का उपयोग करके देख सकते हैं git diff आदेश।

[tom@CentOS src]$ git diff

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

diff --git a/src/string_operations.c b/src/string_operations.c
index 8ab7f42..f282fcf 100644
--- a/src/string_operations.c
+++ b/src/string_operations.c
@@ -1,5 +1,16 @@
#include <stdio.h>
+char *my_strcat(char *t, char *s)
diff --git a/src/string_operations.c b/src/string_operations.c
index 8ab7f42..f282fcf 100644
--- a/src/string_operations.c
+++ b/src/string_operations.c
@@ -1,5 +1,16 @@
#include <stdio.h>
+char *my_strcat(char *t, char *s)
+
{
   +
   char *p = t;
   +
   +
   +
   while (*p)
   ++p;
   +
   while (*p++ = *s++)
   + ;
   + return t;
   +
}
+
size_t my_strlen(const char *s)
{
   const char *p = s;
   @@ -23,6 +34,7 @@ int main(void)
   {

शाखा संचालन विकास की एक और पंक्ति बनाने की अनुमति देता है। हम इस प्रक्रिया का उपयोग विकास प्रक्रिया को दो अलग-अलग दिशाओं में बंद करने के लिए कर सकते हैं। उदाहरण के लिए, हमने 6.0 संस्करण के लिए एक उत्पाद जारी किया और हम एक शाखा बनाना चाह सकते हैं ताकि 7.0 सुविधाओं के विकास को 6.0% फिक्स से अलग रखा जा सके।

शाखा बनाएँ

टॉम git शाखा <शाखा का नाम> कमांड का उपयोग करके एक नई शाखा बनाता है। हम एक मौजूदा से एक नई शाखा बना सकते हैं। हम शुरुआती बिंदु के रूप में एक विशिष्ट प्रतिबद्ध या टैग का उपयोग कर सकते हैं। यदि कोई विशिष्ट प्रतिबद्ध आईडी प्रदान नहीं की गई है, तो शाखा को उसके आरंभिक बिंदु के रूप में हेड बनाया जाएगा।

[jerry@CentOS src]$ git branch new_branch [jerry@CentOS src]$ git branch
* master
new_branch

एक नई शाखा बनाई जाती है; टॉम ने उपलब्ध शाखाओं को सूचीबद्ध करने के लिए git शाखा कमांड का उपयोग किया। वर्तमान में जाँच की गई शाखा से पहले Git एक तारांकन चिह्न दिखाता है।

शाखा संचालन बनाने का सचित्र प्रतिनिधित्व नीचे दिखाया गया है -

शाखाओं के बीच स्विच करें

जेरी शाखाओं के बीच स्विच करने के लिए git चेकआउट कमांड का उपयोग करता है।

[jerry@CentOS src]$ git checkout new_branch Switched to branch 'new_branch' [jerry@CentOS src]$ git branch
master
* new_branch

शाखा बनाने और स्विच करने के लिए शॉर्टकट

उपरोक्त उदाहरण में, हमने क्रमशः शाखाओं को बनाने और स्विच करने के लिए दो आदेशों का उपयोग किया है। गिट प्रदान करता है–bचेकआउट कमांड के साथ विकल्प; यह ऑपरेशन एक नई शाखा बनाता है और तुरंत नई शाखा में बदल जाता है।

[jerry@CentOS src]$ git checkout -b test_branch Switched to a new branch 'test_branch' [jerry@CentOS src]$ git branch
master
new_branch
* test_branch

एक शाखा हटाएँ

Git ब्रांच कमांड के साथ –D विकल्प प्रदान करके एक शाखा को हटाया जा सकता है। लेकिन मौजूदा शाखा को हटाने से पहले, दूसरी शाखा पर जाएँ।

जेरी फिलहाल हैं test_branchऔर वह उस शाखा को हटाना चाहता है। इसलिए वह शाखा को स्विच करता है और नीचे दिखाए अनुसार शाखा को हटा देता है।

[jerry@CentOS src]$ git branch master new_branch * test_branch [jerry@CentOS src]$ git checkout master
Switched to branch 'master'

[jerry@CentOS src]$ git branch -D test_branch
Deleted branch test_branch (was 5776472).

अब, Git केवल दो शाखाओं को दिखाएगा।

[jerry@CentOS src]$ git branch
* master
new_branch

एक शाखा का नाम बदलें

जेरी ने अपने स्ट्रिंग ऑपरेशन प्रोजेक्ट में व्यापक पात्रों के लिए समर्थन जोड़ने का फैसला किया। उसने पहले ही एक नई शाखा बना ली है, लेकिन शाखा का नाम उचित नहीं है। इसलिए वह शाखा का नाम बदलकर उपयोग करता है–m इसके बाद विकल्प old branch name और यह new branch name।

[jerry@CentOS src]$ git branch * master new_branch [jerry@CentOS src]$ git branch -m new_branch wchar_support

अब, git ब्रांच कमांड नई ब्रांच का नाम दिखाएगा।

[jerry@CentOS src]$ git branch
* master
wchar_support

दो शाखाओं को मिलाएं

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

[jerry@CentOS src]$ git branch
master
* wchar_support

[jerry@CentOS src]$ pwd /home/jerry/jerry_repo/project/src [jerry@CentOS src]$ git diff

उपरोक्त आदेश निम्नलिखित परिणाम उत्पन्न करता है -

t a/src/string_operations.c b/src/string_operations.c
index 8ab7f42..8fb4b00 100644
--- a/src/string_operations.c
+++ b/src/string_operations.c
@@ -1,4 +1,14 @@
#include <stdio.h>
+#include <wchar.h>
+
+size_t w_strlen(const wchar_t *s)
+
{
   +
   const wchar_t *p = s;
   +
   +
   while (*p)
   + ++p;
   + return (p - s);
   +
}

परीक्षण के बाद, वह नई शाखा में अपने परिवर्तनों को लागू करता है और धक्का देता है।

[jerry@CentOS src]$ git status -s M string_operations.c ?? string_operations [jerry@CentOS src]$ git add string_operations.c

[jerry@CentOS src]$ git commit -m 'Added w_strlen function to return string lenght of wchar_t
string'

[wchar_support 64192f9] Added w_strlen function to return string lenght of wchar_t string
1 files changed, 10 insertions(+), 0 deletions(-)

ध्यान दें कि जेरी इन परिवर्तनों को नई शाखा में धकेल रहा है, यही कारण है कि उसने शाखा नाम का उपयोग किया है wchar_support के बजाय master डाली।

[jerry@CentOS src]$ git push origin wchar_support  <−−− Observer branch_name

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

Counting objects: 7, done.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 507 bytes, done.
Total 4 (delta 1), reused 0 (delta 0)
To [email protected]:project.git
* [new branch]
wchar_support -> wchar_support

परिवर्तनों को करने के बाद, नई शाखा निम्नानुसार दिखाई देगी -

टॉम इस बारे में उत्सुक है कि जेरी अपनी निजी शाखा में क्या कर रहा है और वह लॉग इन की जाँच करता है wchar_support डाली।

[tom@CentOS src]$ pwd /home/tom/top_repo/project/src [tom@CentOS src]$ git log origin/wchar_support -2

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

commit 64192f91d7cc2bcdf3bf946dd33ece63b74184a3
Author: Jerry Mouse <[email protected]>
Date: Wed Sep 11 16:10:06 2013 +0530

Added w_strlen function to return string lenght of wchar_t string


commit 577647211ed44fe2ae479427a0668a4f12ed71a1
Author: Tom Cat <[email protected]>
Date: Wed Sep 11 10:21:20 2013 +0530

Removed executable binary

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

[tom@CentOS project]$ git branch * master [tom@CentOS project]$ pwd
/home/tom/top_repo/project

[tom@CentOS project]$ git merge origin/wchar_support
Updating 5776472..64192f9
Fast-forward
src/string_operations.c | 10 ++++++++++
1 files changed, 10 insertions(+), 0 deletions(-)

मर्ज ऑपरेशन के बाद, मास्टर शाखा निम्नानुसार दिखाई देगी -

अब, शाखा wchar_supportमास्टर शाखा के साथ विलय कर दिया गया है। हम इसे प्रतिबद्ध संदेश देखकर या string_operation.c फ़ाइल में किए गए संशोधनों को देखकर सत्यापित कर सकते हैं।

[tom@CentOS project]$ cd src/

[tom@CentOS src]$ git log -1

commit 64192f91d7cc2bcdf3bf946dd33ece63b74184a3
Author: Jerry Mouse 
      
        Date: Wed Sep 11 16:10:06 2013 +0530 Added w_strlen function to return string lenght of wchar_t string [tom@CentOS src]$ head -12 string_operations.c 
      

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा।

#include <stdio.h>
#include <wchar.h>
size_t w_strlen(const wchar_t *s)
{
   const wchar_t *p = s;

   while (*p)
      ++p;

   return (p - s);
}

परीक्षण के बाद, वह अपने कोड परिवर्तन को मास्टर शाखा में धकेलता है।

[tom@CentOS src]$ git push origin master
Total 0 (delta 0), reused 0 (delta 0)
To [email protected]:project.git
5776472..64192f9 master −> master

रिबेस शाखाओं

Git rebase कमांड एक ब्रांच मर्ज कमांड है, लेकिन अंतर यह है कि यह कमिट के क्रम को संशोधित करता है।

Git मर्ज कमांड वर्तमान स्थानीय शाखा के HEAD के ऊपर अन्य शाखाओं से कमिट्स लगाने की कोशिश करता है। उदाहरण के लिए, आपकी स्थानीय शाखा ने A−> B−> C D> D और मर्ज शाखा ने A−> B−> X−> Y किया है, तो git मर्ज वर्तमान स्थानीय शाखा को A−> जैसी किसी चीज़ में बदल देगा। बी> सी> डी> एक्स> Y

Git rebase कमांड वर्तमान स्थानीय शाखा और मर्ज शाखा के बीच सामान्य पूर्वजों का पता लगाने की कोशिश करता है। यह वर्तमान स्थानीय शाखा में आवागमन के क्रम को संशोधित करके स्थानीय शाखा में आवागमन को आगे बढ़ाता है। उदाहरण के लिए, यदि आपकी स्थानीय शाखा ने A,> B−> C D> D और मर्ज शाखा ने A−> B−> X−> Y किया है, तो Git rebase वर्तमान स्थानीय शाखा को A− जैसी किसी चीज़ में बदल देगा। > बी> एक्स> Y-> सी> डी।

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

Wchar_support शाखा में परिवर्तन करें

जेरी पर काम कर रहा है wchar_supportडाली। वह कार्यों का नाम बदल देता है और परीक्षण के बाद, वह अपने परिवर्तनों को करता है।

[jerry@CentOS src]$ git branch
 master
* wchar_support
[jerry@CentOS src]$ git diff

उपरोक्त आदेश निम्नलिखित परिणाम उत्पन्न करता है -

diff --git a/src/string_operations.c b/src/string_operations.c
index 8fb4b00..01ff4e0 100644
--- a/src/string_operations.c
+++ b/src/string_operations.c
@@ -1,7 +1,7 @@
#include <stdio.h>
#include <wchar.h>
-size_t w_strlen(const wchar_t *s)
+size_t my_wstrlen(const wchar_t *s)
{
   const wchar_t *p = s;

कोड को सत्यापित करने के बाद वह अपने बदलाव करता है।

[jerry@CentOS src]$ git status -s
M string_operations.c

[jerry@CentOS src]$ git add string_operations.c [jerry@CentOS src]$ git commit -m 'Changed function name'
[wchar_support 3789fe8] Changed function name
1 files changed, 1 insertions(+), 1 deletions(-)

[jerry@CentOS src]$ git push origin wchar_support

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

Counting objects: 7, done.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 409 bytes, done.
Total 4 (delta 1), reused 0 (delta 0)
To [email protected]:project.git
64192f9..3789fe8 wchar_support -> wchar_support

मास्टर ब्रांच में बदलाव करें

इस बीच, मास्टर शाखा में, टॉम भी उसी फ़ंक्शन का नाम बदलता है और मास्टर शाखा में अपने परिवर्तनों को धकेलता है।

[tom@CentOS src]$ git branch
* master
[tom@CentOS src]$ git diff

उपरोक्त आदेश निम्नलिखित परिणाम उत्पन्न करता है -

diff --git a/src/string_operations.c b/src/string_operations.c
index 8fb4b00..52bec84 100644
--- a/src/string_operations.c
+++ b/src/string_operations.c
@@ -1,7 +1,8 @@
#include <stdio.h>
#include <wchar.h>
-size_t w_strlen(const wchar_t *s)
+/* wide character strlen fucntion */
+size_t my_wc_strlen(const wchar_t *s)
{
   const wchar_t *p = s;

अलग-अलग सत्यापित करने के बाद, वह अपने परिवर्तनों को करता है।

[tom@CentOS src]$ git status -s
M string_operations.c

[tom@CentOS src]$ git add string_operations.c [tom@CentOS src]$ git commit -m 'Changed function name from w_strlen to my_wc_strlen'
[master ad4b530] Changed function name from w_strlen to my_wc_strlen
1 files changed, 2 insertions(+), 1 deletions(-)

[tom@CentOS src]$ git push origin master

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

Counting objects: 7, done.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 470 bytes, done.
Total 4 (delta 1), reused 0 (delta 0)
To [email protected]:project.git
64192f9..ad4b530 master -> master

पर wchar_supportशाखा, जेरी व्यापक चरित्र स्ट्रिंग के लिए strchr फ़ंक्शन लागू करता है। परीक्षण के बाद, वह अपने परिवर्तनों को करता है और धक्का देता हैwchar_support डाली।

[jerry@CentOS src]$ git branch
master
* wchar_support
[jerry@CentOS src]$ git diff

उपरोक्त आदेश निम्नलिखित परिणाम उत्पन्न करता है -

diff --git a/src/string_operations.c b/src/string_operations.c
index 01ff4e0..163a779 100644
--- a/src/string_operations.c
+++ b/src/string_operations.c
@@ -1,6 +1,16 @@
#include <stdio.h>
#include <wchar.h>
+wchar_t *my_wstrchr(wchar_t *ws, wchar_t wc)
+
{
   +
   while (*ws) 
   {
      +
      if (*ws == wc)
      +
      return ws;
      +
      ++ws;
      + 
   }
   + return NULL;
   +
}
+
size_t my_wstrlen(const wchar_t *s)
{
   const wchar_t *p = s;

सत्यापित करने के बाद, वह अपने परिवर्तन करता है।

[jerry@CentOS src]$ git status -s
M string_operations.c

[jerry@CentOS src]$ git add string_operations.c [jerry@CentOS src]$ git commit -m 'Addded strchr function for wide character string'
[wchar_support 9d201a9] Addded strchr function for wide character string
1 files changed, 10 insertions(+), 0 deletions(-)

[jerry@CentOS src]$ git push origin wchar_support

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा -

Counting objects: 7, done.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 516 bytes, done.
Total 4 (delta 1), reused 0 (delta 0)
To [email protected]:project.git
3789fe8..9d201a9 wchar_support -> wchar_support

टैकल संघर्ष

टॉम देखना चाहता है कि जेरी अपनी निजी शाखा में क्या कर रहा है, इसलिए वह नवीनतम परिवर्तनों को खींचने की कोशिश करता है wchar_support शाखा, लेकिन Git निम्नलिखित त्रुटि संदेश के साथ ऑपरेशन को रोक देता है।

[tom@CentOS src]$ git pull origin wchar_support

उपरोक्त आदेश निम्नलिखित परिणाम उत्पन्न करता है -

remote: Counting objects: 11, done.
63Git Tutorials
remote: Compressing objects: 100% (8/8), done.
remote: Total 8 (delta 2), reused 0 (delta 0)
Unpacking objects: 100% (8/8), done.
From git.server.com:project
* branch
wchar_support -> FETCH_HEAD
Auto-merging src/string_operations.c
CONFLICT (content): Merge conflict in src/string_operations.c
Automatic merge failed; fix conflicts and then commit the result.

विवादों को सुलझाओ

त्रुटि संदेश से, यह स्पष्ट है कि src / string_operations.c में एक संघर्ष है। वह आगे विवरण देखने के लिए git diff कमांड चलाता है।

[tom@CentOS src]$ git diff

उपरोक्त आदेश निम्नलिखित परिणाम उत्पन्न करता है -

diff --cc src/string_operations.c
index 52bec84,163a779..0000000
--- a/src/string_operations.c
+++ b/src/string_operations.c
@@@ -1,8 -1,17 +1,22 @@@
#include <stdio.h>
#include <wchar.h>
++<<<<<<< HEAD
+/* wide character strlen fucntion */
+size_t my_wc_strlen(const wchar_t *s)
++=======
+ wchar_t *my_wstrchr(wchar_t *ws, wchar_t wc)
+
{
   +
   +
   while (*ws) 
   {
      if (*ws == wc)
      +
      return ws;
      +
      ++ws;
      + 
   }
   + return NULL;
   +
}
+
+ size_t my_wstrlen(const wchar_t *s)
++>>>>>>>9d201a9c61bc4713f4095175f8954b642dae8f86
{
   const wchar_t *p = s;

जैसा कि टॉम और जेरी दोनों ने एक ही फ़ंक्शन का नाम बदल दिया, गिट एक भ्रम की स्थिति में है और यह उपयोगकर्ता को मैन्युअल रूप से संघर्ष को हल करने के लिए कहता है।

टॉम जेरी द्वारा सुझाए गए फ़ंक्शन का नाम रखने का फैसला करता है, लेकिन वह उसके द्वारा जोड़ा गया टिप्पणी रखता है, जैसा कि यह है। संघर्ष मार्करों को हटाने के बाद, गिट भिन्न इस तरह दिखाई देगा।

[tom@CentOS src]$ git diff

उपरोक्त आदेश निम्नलिखित परिणाम उत्पन्न करता है।

diff --cc src/string_operations.c
diff --cc src/string_operations.c
index 52bec84,163a779..0000000
--- a/src/string_operations.c
+++ b/src/string_operations.c
@@@ -1,8 -1,17 +1,18 @@@
#include <stdio.h>
#include <wchar.h>
+ wchar_t *my_wstrchr(wchar_t *ws, wchar_t wc)
+
{
   +
   while (*ws) 
   {
      +
      if (*ws == wc)
      +
      return ws;
      +
      ++ws;
      + 
   }
   + return NULL;
   +
}
+
+/* wide character strlen fucntion */
- size_t my_wc_strlen(const wchar_t *s)
+ size_t my_wstrlen(const wchar_t *s)
{
   const wchar_t *p = s;

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

[tom@CentOS src]$ git commit -a -m 'Resolved conflict' [master 6b1ac36] Resolved conflict [tom@CentOS src]$ git pull origin wchar_support.

टॉम ने संघर्ष को हल कर दिया है, अब पुल ऑपरेशन सफल होगा।

GNU / Linux और Mac OS का उपयोग करता है line-feed (LF), या नई लाइन लाइन एंडिंग कैरेक्टर के रूप में, जबकि विंडोज उपयोग करता है line-feed and carriage-return (LFCR) लाइन समाप्त करने वाले चरित्र का प्रतिनिधित्व करने के लिए संयोजन।

इन लाइन-एंडिंग अंतरों के कारण अनावश्यक कमिट्स से बचने के लिए, हमें Git रिपॉजिटरी में समाप्त होने वाली समान लाइन लिखने के लिए Git क्लाइंट को कॉन्फ़िगर करना होगा।

विंडोज सिस्टम के लिए, हम लाइन एंडिंग को कन्वर्ट करने के लिए Git क्लाइंट को कॉन्फ़िगर कर सकते हैं CRLF प्रारूप की जाँच करते समय, और उन्हें वापस रूपांतरित करें LFप्रारूप संचालन के दौरान। निम्न सेटिंग्स की आवश्यकता होगी।

[tom@CentOS project]$ git config --global core.autocrlf true

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

[tom@CentOS project]$ git config --global core.autocrlf input

GitHubसॉफ्टवेयर विकास परियोजनाओं के लिए एक वेब-आधारित होस्टिंग सेवा है जो Git संशोधन नियंत्रण प्रणाली का उपयोग करती है। इसमें सेवा के वेबसाइट से सीधे डाउनलोड के लिए उनके मानक जीयूआई एप्लिकेशन (विंडोज, मैक, जीएनयू / लिनक्स) उपलब्ध हैं। लेकिन इस सत्र में, हम केवल सीएलआई भाग देखेंगे।

GitHub रिपोजिटरी बनाएँ

Github.com पर जाएं । यदि आपके पास पहले से हैGitHubखाता, फिर उस खाते का उपयोग करके लॉगिन करें या नया बनाएं। एक नया भंडार बनाने के लिए github.com वेबसाइट के चरणों का पालन करें ।

पुश ऑपरेशन

टॉम का उपयोग करने का फैसला किया GitHubसर्वर। एक नई परियोजना शुरू करने के लिए, वह एक नई निर्देशिका और उसके अंदर एक फ़ाइल बनाता है।

[tom@CentOS]$ mkdir github_repo [tom@CentOS]$ cd github_repo/

[tom@CentOS]$ vi hello.c [tom@CentOS]$ make hello
cc hello.c -o hello

[tom@CentOS]$ ./hello

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा:

Hello, World !!!

अपने कोड को सत्यापित करने के बाद, वह निर्देशिका को गिट इनिट कमांड के साथ आरंभ करता है और स्थानीय रूप से अपने बदलाव करता है।

[tom@CentOS]$ git init
Initialized empty Git repository in /home/tom/github_repo/.git/

[tom@CentOS]$ git status -s ?? hello ?? hello.c [tom@CentOS]$ git add hello.c

[tom@CentOS]$ git status -s A hello.c ?? hello [tom@CentOS]$ git commit -m 'Initial commit'

उसके बाद, वह कहते हैं GitHub दूरस्थ स्थान के रूप में रिपॉजिटरी URL और दूरस्थ रिपॉजिटरी में उसके बदलावों को आगे बढ़ाता है।

[tom@CentOS]$ git remote add origin https://github.com/kangralkar/testing_repo.git [tom@CentOS]$ git push -u origin master

पुश ऑपरेशन मांगेगा GitHubउपयोगकर्ता नाम और पासवर्ड। सफल प्रमाणीकरण के बाद, ऑपरेशन सफल होगा।

उपरोक्त आदेश निम्नलिखित परिणाम का उत्पादन करेगा:

Username for 'https://github.com': kangralkar
Password for 'https://[email protected]': 
Counting objects: 3, done.
Writing objects: 100% (3/3), 214 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To https://github.com/kangralkar/test_repo.git
 * [new branch]      master −> master
 Branch master set up to track remote branch master from origin.

अब से, टॉम किसी भी बदलाव को आगे बढ़ा सकता है GitHubभंडार। वह इस अध्याय में चर्चा की गई सभी कमांड का उपयोग कर सकता हैGitHub भंडार।

खींचो ऑपरेशन

टॉम ने अपने सभी परिवर्तनों को सफलतापूर्वक धकेल दिया GitHubभंडार। अब, अन्य डेवलपर्स क्लोन ऑपरेशन करके या अपने स्थानीय भंडार को अपडेट करके इन परिवर्तनों को देख सकते हैं।

जेरी अपने घर निर्देशिका में एक नई निर्देशिका बनाता है और क्लोन करता है GitHub git क्लोन कमांड का उपयोग करके रिपॉजिटरी।

[jerry@CentOS]$ pwd /home/jerry [jerry@CentOS]$ mkdir jerry_repo

[jerry@CentOS]$ git clone https://github.com/kangralkar/test_repo.git

उपरोक्त आदेश निम्नलिखित परिणाम उत्पन्न करता है:

Cloning into 'test_repo'...
remote: Counting objects: 3, done.
remote: Total 3 (delta 0), reused 3 (delta 0)
Unpacking objects: 100% (3/3), done.

वह ls कमांड को निष्पादित करके निर्देशिका सामग्री की पुष्टि करता है।

[jerry@CentOS]$ ls
test_repo

[jerry@CentOS]$ ls test_repo/
hello.c