Git सह प्रारंभ करणे: नवशिक्यांसाठी सर्वसमावेशक मार्गदर्शक

परिचयाऐवजी

नमस्कार! आज आपण Git नावाच्या आवृत्ती नियंत्रण प्रणालीबद्दल बोलणार आहोत. तुम्हाला Git माहित नसेल/समजत नसेल तर प्रोग्रामिंगशी तुमचा काही संबंध नाही. परंतु सौंदर्य हे आहे की सतत कार्यरत राहण्यासाठी तुम्हाला सर्व Git आज्ञा आणि वैशिष्ट्ये तुमच्या डोक्यात ठेवण्याची गरज नाही. तुम्हाला आज्ञांचा संच माहित असणे आवश्यक आहे जे घडत असलेल्या सर्व गोष्टी समजून घेण्यास मदत करेल.

Git मूलभूत

आमच्या कोडसाठी गिट ही वितरित आवृत्ती नियंत्रण प्रणाली आहे. आम्हाला त्याची गरज का आहे? वितरित संघांना त्यांचे कार्य व्यवस्थापित करण्यासाठी काही प्रकारच्या प्रणालीची आवश्यकता असते. कालांतराने होणाऱ्या बदलांचा मागोवा घेणे आवश्यक आहे. म्हणजेच, कोणत्या फायली बदलल्या आहेत आणि कशा बदलल्या आहेत हे आपल्याला चरण-दर-चरण पाहण्यास सक्षम असणे आवश्यक आहे. हे विशेषतः महत्वाचे आहे जेव्हा तुम्ही एका कार्याच्या संदर्भात काय बदलले आहे ते तपासत आहात, बदल परत करणे शक्य करते.

Git स्थापित करत आहे

चला तुमच्या संगणकावर Java इंस्टॉल करू.

विंडोजवर इन्स्टॉल करत आहे

नेहमीप्रमाणे, तुम्हाला exe फाइल डाउनलोड करून चालवावी लागेल. येथे सर्व काही सोपे आहे: पहिल्या Google दुव्यावर क्लिक करा , स्थापित करा आणि तेच झाले. हे करण्यासाठी, आम्ही विंडोजद्वारे प्रदान केलेले बॅश कन्सोल वापरू. विंडोजवर, तुम्हाला गिट बॅश चालवावी लागेल. स्टार्ट मेनूमध्ये ते कसे दिसते ते येथे आहे: आता हे एक कमांड प्रॉम्प्ट आहे ज्यावर तुम्ही काम करू शकता. गिट उघडण्यासाठी प्रत्येक वेळी प्रोजेक्टसह फोल्डरमध्ये जाणे टाळण्यासाठी, आपण आवश्यक असलेल्या मार्गासह उजव्या माऊस बटणाने प्रोजेक्ट फोल्डरमध्ये कमांड प्रॉम्प्ट उघडू शकता:

लिनक्सवर इन्स्टॉल करत आहे

सहसा Git हा लिनक्स वितरणाचा भाग असतो आणि तो आधीपासूनच स्थापित केलेला असतो, कारण ते मूळतः लिनक्स कर्नल विकासासाठी लिहिलेले साधन आहे. परंतु अशी परिस्थिती असते जेव्हा ती नसते. तपासण्यासाठी, तुम्हाला टर्मिनल उघडावे लागेल आणि लिहावे लागेल: git --version. जर तुम्हाला समजण्याजोगे उत्तर मिळाले तर काहीही स्थापित करण्याची गरज नाही. टर्मिनल उघडा आणि उबंटूवर Git स्थापित करा . मी उबंटू वर काम करत आहे, त्यामुळे त्यासाठी काय लिहायचे ते मी सांगू शकतो: sudo apt-get install git.

macOS वर स्थापित करत आहे

येथे देखील, आपल्याला प्रथम Git तेथे आहे की नाही हे तपासण्याची आवश्यकता आहे. तुमच्याकडे ते नसल्यास, ते मिळवण्याचा सर्वात सोपा मार्ग म्हणजे नवीनतम आवृत्ती येथे डाउनलोड करणे . जर Xcode स्थापित केले असेल, तर Git निश्चितपणे स्वयंचलितपणे स्थापित होईल.

Git सेटिंग्ज

Git मध्ये वापरकर्त्यासाठी वापरकर्ता सेटिंग्ज आहेत जे काम सबमिट करतील. हे अर्थपूर्ण आणि आवश्यक आहे, कारण कमिट तयार केल्यावर गिट ही माहिती लेखक फील्डसाठी घेते. खालील आदेश चालवून तुमच्या सर्व प्रकल्पांसाठी वापरकर्तानाव आणि पासवर्ड सेट करा:

git config --global user.name "Ivan Ivanov"
git config --global user.email ivan.ivanov@gmail.com

तुम्हाला एखाद्या विशिष्ट प्रकल्पासाठी लेखक बदलण्याची आवश्यकता असल्यास, तुम्ही "--global" काढू शकता. हे आम्हाला पुढील गोष्टी देईल:

git config user.name "Ivan Ivanov"
git config user.email ivan.ivanov@gmail.com

थोडा सिद्धांत...

विषयात जाण्यासाठी, आम्ही तुम्हाला काही नवीन शब्द आणि कृतींशी ओळख करून द्यायला हवी...

• git भांडार
• वचनबद्ध
• शाखा
• विलीन
• संघर्ष
• खेचणे
• ढकलणे
• काही फाइल्सकडे दुर्लक्ष कसे करावे (.gitignore)

वगैरे.

Git मधील स्थिती

गिटमध्ये अनेक पुतळे आहेत ज्यांना समजून घेणे आणि लक्षात ठेवणे आवश्यक आहे:

• अनट्रॅक केलेले
• सुधारित
• मंचित
• वचनबद्ध

हे कसे समजून घ्यावे?

आमच्या कोड असलेल्या फायलींवर लागू होणारी ही स्थिती आहेत:

1. फाइल जी तयार केली गेली आहे परंतु अद्याप रिपॉजिटरीमध्ये जोडली गेली नाही तिला "ट्रॅक न केलेले" स्थिती आहे.
2. Git रिपॉझिटरीमध्ये आधीच जोडलेल्या फाईल्समध्ये आम्ही बदल करतो तेव्हा त्यांची स्थिती "सुधारित" केली जाते.
3. आम्ही बदललेल्या फायलींपैकी, आम्ही आवश्यक असलेल्या फाइल्स निवडतो आणि हे वर्ग "स्टेज्ड" स्थितीत बदलले जातात.
4. स्टेज केलेल्या स्थितीत तयार केलेल्या फाइल्समधून कमिट तयार केले जाते आणि Git रेपॉजिटरीमध्ये जाते. त्यानंतर, "स्टेज्ड" स्थिती असलेल्या कोणत्याही फायली नाहीत. परंतु तरीही अशा फाइल्स असू शकतात ज्यांची स्थिती "सुधारित" आहे.

ते कसे दिसते ते येथे आहे:

कमिट म्हणजे काय?

जेव्हा आवृत्ती नियंत्रण येते तेव्हा कमिट ही मुख्य घटना असते. कमिट सुरू झाल्यापासून केलेले सर्व बदल त्यात समाविष्ट आहेत. कमिट एकल लिंक केलेल्या सूचीप्रमाणे एकत्र जोडलेले आहेत. अधिक विशेषतः: प्रथम वचनबद्धता आहे. जेव्हा दुसरी कमिट तयार केली जाते, तेव्हा पहिल्या नंतर काय येते हे माहित असते. आणि या पद्धतीने माहितीचा मागोवा घेता येतो. कमिटची स्वतःची माहिती देखील असते, तथाकथित मेटाडेटा:

• कमिटचा युनिक आयडेंटिफायर, जो तो शोधण्यासाठी वापरला जाऊ शकतो
• कमिटच्या लेखकाचे नाव, ज्याने ते तयार केले
• कमिट तयार केल्याची तारीख
• कमिट दरम्यान काय केले गेले याचे वर्णन करणारी टिप्पणी

ते कसे दिसते ते येथे आहे:

शाखा म्हणजे काय?

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

Git सह प्रारंभ करणे

तुम्ही स्थानिक रेपॉजिटरीसह तसेच रिमोटसह काम करू शकता. आवश्यक आदेशांचा सराव करण्यासाठी, तुम्ही स्वतःला स्थानिक भांडारात मर्यादित करू शकता. हे फक्त .git फोल्डरमध्ये स्थानिक पातळीवर प्रकल्पाची सर्व माहिती संग्रहित करते. जर आपण रिमोट रेपॉजिटरीबद्दल बोलत असाल तर सर्व माहिती रिमोट सर्व्हरवर कुठेतरी संग्रहित केली जाते: प्रकल्पाची फक्त एक प्रत स्थानिकरित्या संग्रहित केली जाते. तुमच्या स्थानिक प्रतीमध्ये केलेले बदल रिमोट रिपॉझिटरीमध्ये (गिट पुश) ढकलले जाऊ शकतात. येथे आणि खाली आमच्या चर्चेत, आम्ही कन्सोलमध्ये Git सह काम करण्याबद्दल बोलत आहोत. अर्थात, तुम्ही काही प्रकारचे GUI-आधारित सोल्यूशन वापरू शकता (उदाहरणार्थ, IntelliJ IDEA), परंतु प्रथम तुम्ही कोणते आदेश कार्यान्वित केले जात आहेत आणि त्यांचा अर्थ काय हे शोधून काढले पाहिजे.

स्थानिक भांडारात Git सह कार्य करणे

पुढे, मी सुचवितो की तुम्ही सोबत अनुसरण करा आणि तुम्ही लेख वाचल्याप्रमाणे मी केलेल्या सर्व चरणांचे पालन करा. हे तुमची समज आणि सामग्रीचे प्रभुत्व सुधारेल. बरं, बोन एपेटिट! :) स्थानिक भांडार तयार करण्यासाठी, तुम्हाला लिहावे लागेल:

git init

हे कन्सोलच्या वर्तमान निर्देशिकेत .git फोल्डर तयार करेल. .git फोल्डर Git रेपॉजिटरीबद्दल सर्व माहिती संग्रहित करते. ते हटवू नका ;) पुढे, फायली प्रकल्पात जोडल्या जातात आणि त्यांना "अनट्रॅक केलेले" स्थिती नियुक्त केली जाते. तुमच्या कामाची सद्यस्थिती तपासण्यासाठी, हे लिहा:

git status

आम्ही मुख्य शाखेत आहोत, आणि आम्ही दुसर्‍या शाखेत जाईपर्यंत इथेच राहू. हे दर्शवते की कोणत्या फायली बदलल्या आहेत परंतु अद्याप "स्टेज" स्थितीमध्ये जोडल्या गेल्या नाहीत. त्यांना "स्टेज्ड" स्टेटसमध्ये जोडण्यासाठी, तुम्हाला "गिट अॅड" लिहावे लागेल. आमच्याकडे येथे काही पर्याय आहेत, उदाहरणार्थ:

• git add -A — सर्व फायली "स्टेज्ड" स्थितीत जोडा
• git जोडा. - या फोल्डरमधील सर्व फायली आणि सर्व सबफोल्डर्स जोडा. मूलत:, हे मागील सारखेच आहे
• git add <file name> — विशिष्ट फाइल जोडते. येथे तुम्ही काही पॅटर्ननुसार फाइल्स जोडण्यासाठी रेग्युलर एक्सप्रेशन वापरू शकता. उदाहरणार्थ, git add *.java: याचा अर्थ तुम्हाला फक्त जावा एक्स्टेंशनसह फाइल्स जोडायच्या आहेत.

पहिले दोन पर्याय स्पष्टपणे सोपे आहेत. नवीनतम जोडणीसह गोष्टी अधिक मनोरंजक होतात, म्हणून चला लिहूया:

git add *.txt

स्थिती तपासण्‍यासाठी, आम्‍ही आम्‍हाला आधीच माहीत असलेली कमांड वापरतो:

git status

येथे तुम्ही पाहू शकता की रेग्युलर एक्सप्रेशनने योग्यरित्या कार्य केले आहे: test_resource.txt ला आता "स्टेज" स्थिती आहे. आणि शेवटी, स्थानिक रेपॉजिटरीसह काम करण्याचा शेवटचा टप्पा (रिमोट रिपॉझिटरीसह काम करताना आणखी एक आहे ;)) — नवीन कमिट तयार करणे:

git commit -m "all txt files were added to the project"

शाखेवरील कमिट हिस्ट्री पाहण्यासाठी पुढे एक उत्तम कमांड आहे. चला त्याचा उपयोग करूया:

git log

येथे तुम्ही पाहू शकता की आम्ही आमची पहिली कमिट तयार केली आहे आणि त्यात आम्ही कमांड लाइनवर दिलेला मजकूर समाविष्ट आहे. हे समजून घेणे फार महत्वाचे आहे की या मजकुरात या वचनबद्धतेदरम्यान काय केले गेले ते शक्य तितके अचूकपणे स्पष्ट केले पाहिजे. हे आम्हाला भविष्यात अनेक वेळा मदत करेल. एक जिज्ञासू वाचक जो अद्याप झोपी गेला नाही तो कदाचित विचार करत असेल की GitTest.java फाइलचे काय झाले. चला आत्ताच शोधूया. हे करण्यासाठी, आम्ही वापरतो:

git status

जसे आपण पाहू शकता, ते अद्याप "अनट्रॅक केलेले" आहे आणि पंखांमध्ये वाट पाहत आहे. पण आम्ही ते प्रकल्पात अजिबात जोडू इच्छित नसल्यास काय? कधी कधी असं होतं. गोष्टी अधिक मनोरंजक बनवण्यासाठी, आता आमची test_resource.txt फाइल बदलण्याचा प्रयत्न करूया. चला तेथे काही मजकूर जोडू आणि स्थिती तपासू:

git status

येथे तुम्ही "अनट्रॅक केलेले" आणि "सुधारित" स्थितींमधील फरक स्पष्टपणे पाहू शकता. GitTest.java "untracked" आहे, तर test_resource.txt "सुधारित" आहे. आता आमच्याकडे फाईल्स सुधारित स्थितीत आहेत, आम्ही त्यात केलेले बदल तपासू शकतो. हे खालील आदेश वापरून केले जाऊ शकते:

git diff

म्हणजेच, मी आमच्या मजकूर फाइलमध्ये काय जोडले ते तुम्ही येथे स्पष्टपणे पाहू शकता: हॅलो वर्ल्ड! चला मजकूर फाइलमध्ये आपले बदल जोडू आणि एक वचनबद्धता तयार करू:

git add test_resource.txt
git commit -m "added hello word! to test_resource.txt"

सर्व कमिट पाहण्यासाठी, लिहा:

git log

तुम्ही बघू शकता, आमच्याकडे आता दोन कमिट आहेत. आपण त्याच प्रकारे GitTest.java जोडू. येथे कोणत्याही टिप्पण्या नाहीत, फक्त आज्ञा:

git add GitTest.java
git commit -m "added GitTest.java"
git status

.gitignore सह काम करत आहे

स्पष्टपणे, आम्ही फक्त स्त्रोत कोड ठेवू इच्छितो, आणि इतर काहीही नाही, रेपॉजिटरीमध्ये. मग आणखी काय असू शकते? कमीत कमी, संकलित वर्ग आणि/किंवा विकास वातावरणाद्वारे व्युत्पन्न केलेल्या फाइल्स. गिटला त्यांच्याकडे दुर्लक्ष करण्यास सांगण्यासाठी, आम्हाला एक विशेष फाइल तयार करावी लागेल. हे करा: प्रोजेक्टच्या रूटमध्ये .gitignore नावाची फाईल तयार करा. या फाईलमधील प्रत्येक ओळ दुर्लक्ष करण्यासाठी नमुना दर्शवते. या उदाहरणात, .gitignore फाइल यासारखी दिसेल:

```
*.class
target/
*.iml
.idea/
```

चला पाहुया:

• पहिली ओळ म्हणजे .class एक्स्टेंशन असलेल्या सर्व फाईल्सकडे दुर्लक्ष करणे
• दुसरी ओळ म्हणजे "लक्ष्य" फोल्डर आणि त्यात असलेल्या सर्व गोष्टींकडे दुर्लक्ष करणे
• तिसरी ओळ म्हणजे .iml एक्स्टेंशन असलेल्या सर्व फाइल्सकडे दुर्लक्ष करणे
• चौथी ओळ म्हणजे .idea फोल्डरकडे दुर्लक्ष करणे

चला एक उदाहरण वापरण्याचा प्रयत्न करूया. ते कसे कार्य करते ते पाहण्यासाठी, प्रकल्पात संकलित GitTest.class जोडू आणि प्रकल्प स्थिती तपासू:

git status

स्पष्टपणे, आम्ही चुकून संकलित वर्ग प्रकल्पात जोडू इच्छित नाही (गिट अॅड -ए वापरून). हे करण्यासाठी, एक .gitignore फाइल तयार करा आणि आधी वर्णन केलेल्या सर्व गोष्टी जोडा: आता प्रोजेक्टमध्ये .gitignore फाइल जोडण्यासाठी कमिट वापरू:

git add .gitignore
git commit -m "added .gitignore file"

आणि आता सत्याचा क्षण: आमच्याकडे एक संकलित वर्ग GitTest.class आहे जो "अनट्रॅक केलेला" आहे, जो आम्हाला Git भांडारात जोडायचा नव्हता. आता आपण .gitignore फाईलचे इफेक्ट पाहावे:

git status

परिपूर्ण! .gitignore +1 :)

शाखांसह कार्य करणे आणि अशा

साहजिकच, फक्त एका शाखेत काम करणे एकाकी विकसकांसाठी गैरसोयीचे असते आणि जेव्हा एका संघात एकापेक्षा जास्त व्यक्ती असतात तेव्हा ते अशक्य असते. त्यामुळे आमच्या शाखा आहेत. मी आधी म्हटल्याप्रमाणे, शाखा ही कमिटसाठी फक्त एक जंगम पॉइंटर आहे. या भागात, आम्ही वेगवेगळ्या शाखांमध्ये काम करणार आहोत: एका शाखेतून दुसऱ्या शाखेत बदल कसे विलीन करायचे, कोणते विवाद उद्भवू शकतात आणि बरेच काही. रेपॉजिटरीमधील सर्व शाखांची सूची पाहण्यासाठी आणि तुम्ही कोणत्या शाखेत आहात हे समजून घेण्यासाठी, तुम्हाला लिहावे लागेल:

git branch -a

आपण पाहू शकता की आमच्याकडे फक्त एक मास्टर शाखा आहे. समोरील तारका आपण त्यात आहोत हे सूचित करतो. तसे, आम्ही कोणत्या शाखेत आहोत हे शोधण्यासाठी तुम्ही "git status" कमांड देखील वापरू शकता. नंतर शाखा तयार करण्यासाठी अनेक पर्याय आहेत (अजूनही असू शकतात — मी वापरत असलेल्या या आहेत):

• आम्ही ज्यामध्ये आहोत त्यावर आधारित नवीन शाखा तयार करा (९९% प्रकरणे)
• विशिष्ट वचनबद्धतेवर आधारित शाखा तयार करा (1% प्रकरणे)

चला एका विशिष्ट कमिटवर आधारित शाखा तयार करू

आम्ही कमिटच्या युनिक आयडेंटिफायरवर अवलंबून राहू. ते शोधण्यासाठी, आम्ही लिहितो:

git log

मी "हॅलो वर्ल्ड जोडले..." या टिप्पणीसह वचनबद्धता हायलाइट केली आहे, त्याचा अद्वितीय ओळखकर्ता 6c44e53d06228f888f2f454d3cb8c1c976dd73f8 आहे. मला या कमिटपासून सुरू होणारी "विकास" शाखा तयार करायची आहे. हे करण्यासाठी, मी लिहितो:

git checkout -b development 6c44e53d06228f888f2f454d3cb8c1c976dd73f8

मास्टर शाखेकडून फक्त पहिल्या दोन कमिटांसह एक शाखा तयार केली जाते. याची पडताळणी करण्यासाठी, आम्ही प्रथम वेगळ्या शाखेत जाण्याचे सुनिश्चित करतो आणि तेथे केलेल्या कमिटांची संख्या पाहतो:

git status
git log

आणि अपेक्षेप्रमाणे, आमच्याकडे दोन कमिट आहेत. तसे, येथे एक मनोरंजक मुद्दा आहे: या शाखेत अद्याप कोणतीही .gitignore फाइल नाही, त्यामुळे आमची संकलित फाइल (GitTest.class) आता "untracked" स्थितीसह हायलाइट केली गेली आहे. आता आम्ही हे लिहून आमच्या शाखांचे पुन्हा पुनरावलोकन करू शकतो:

git branch -a

आपण पाहू शकता की दोन शाखा आहेत: "मास्टर" आणि "विकास". आम्ही सध्या विकासात आहोत.

सध्याच्या एकावर आधारित शाखा बनवू

शाखा तयार करण्याचा दुसरा मार्ग म्हणजे ती दुसर्‍यापासून तयार करणे. मला मास्टर शाखेवर आधारित शाखा तयार करायची आहे. प्रथम, मला त्यावर स्विच करणे आवश्यक आहे आणि पुढील पायरी म्हणजे नवीन तयार करणे. चला पाहुया:

• git चेकआउट मास्टर — मास्टर शाखेवर स्विच करा
• git स्टेटस - आम्ही प्रत्यक्षात मास्टर शाखेत आहोत याची पडताळणी करा

येथे तुम्ही पाहू शकता की आम्ही मुख्य शाखेत स्विच केले आहे, .gitignore फाइल प्रभावी आहे, आणि संकलित वर्ग यापुढे "अनट्रॅक केलेले" म्हणून हायलाइट केला जाणार नाही. आता आम्ही मुख्य शाखेवर आधारित नवीन शाखा तयार करतो:

git checkout -b feature/update-txt-files

जर तुम्हाला खात्री नसेल की ही शाखा "मास्टर" सारखीच आहे की नाही, तुम्ही "गिट लॉग" कार्यान्वित करून आणि सर्व कमिट पाहून सहजपणे तपासू शकता. त्यापैकी चार असावेत.

संघर्ष निराकरण

संघर्ष म्हणजे काय हे जाणून घेण्यापूर्वी, एक शाखा दुसऱ्या शाखेत विलीन करण्याबद्दल बोलणे आवश्यक आहे. हे चित्र एका शाखेचे दुसऱ्या शाखेत विलीनीकरण करण्याची प्रक्रिया दर्शवते: येथे, आपल्याकडे मुख्य शाखा आहे. काही क्षणी, मुख्य शाखेच्या बाहेर दुय्यम शाखा तयार केली जाते आणि नंतर सुधारित केली जाते. काम पूर्ण झाल्यावर, आपल्याला एक शाखा दुसर्‍यामध्ये विलीन करण्याची आवश्यकता आहे. मी विविध वैशिष्ट्यांचे वर्णन करणार नाही: या लेखात, मला फक्त एक सामान्य समज सांगायची आहे. आपल्याला तपशीलांची आवश्यकता असल्यास, आपण ते स्वतः पाहू शकता. आमच्या उदाहरणात, आम्ही वैशिष्ट्य/अपडेट-txt-फाईल्स शाखा तयार केली. शाखेच्या नावाने सूचित केल्याप्रमाणे, आम्ही मजकूर अद्यतनित करत आहोत. आता आपल्याला या कामासाठी नवीन कमिट तयार करण्याची आवश्यकता आहे:

git add *.txt 
git commit -m "updated txt files"
git log

आता, जर आम्हाला फीचर/अपडेट-txt-फाईल्स शाखा मास्टरमध्ये विलीन करायची असेल, तर आम्हाला मास्टरमध्ये जाऊन "git merge feature/update-txt-files" लिहावे लागेल:

git checkout master
git merge feature/update-txt-files
git log

परिणामी, आता मास्टर ब्रँचमध्ये फीचर/अपडेट-txt-फाईल्समध्ये जोडलेल्या कमिटचाही समावेश होतो. ही कार्यक्षमता जोडली गेली, त्यामुळे तुम्ही वैशिष्ट्य शाखा हटवू शकता. हे करण्यासाठी, आम्ही लिहितो:

git branch -D feature/update-txt-files

आतापर्यंत सर्व काही स्पष्ट आहे, होय? चला परिस्थिती क्लिष्ट करूया: आता असे म्हणूया की आपल्याला txt फाइल पुन्हा बदलण्याची आवश्यकता आहे. मात्र आता मास्टर ब्रँचमध्येही ही फाइल बदलण्यात येणार आहे. दुसऱ्या शब्दांत, ते समांतर बदलेल. जेव्हा आम्हाला आमचा नवीन कोड मास्टर ब्रँचमध्ये विलीन करायचा असेल तेव्हा काय करावे हे गिट समजू शकणार नाही. चल जाऊया! आम्ही मास्टरवर आधारित नवीन शाखा तयार करू, text_resource.txt मध्ये बदल करू आणि या कामासाठी एक वचनबद्धता तयार करू:

git checkout -b feature/add-header
... we make changes to the file

git add *.txt
git commit -m "added header to txt"

मास्टर शाखेत जा आणि फीचर ब्रँच प्रमाणेच ही मजकूर फाईल देखील अपडेट करा:

git checkout master
… we updated test_resource.txt

git add test_resource.txt
git commit -m "added master header to txt"

आणि आता सर्वात मनोरंजक मुद्दा: आम्हाला वैशिष्ट्य/अॅड-हेडर शाखेतील बदल मास्टरमध्ये विलीन करणे आवश्यक आहे. आम्ही मुख्य शाखेत आहोत, म्हणून आम्हाला फक्त लिहायचे आहे:

git merge feature/add-header

पण परिणाम test_resource.txt फाइलमध्ये संघर्ष होईल: येथे आपण पाहू शकतो की हा कोड कसा विलीन करायचा हे Git स्वतः ठरवू शकत नाही. हे आपल्याला सांगते की आपण प्रथम संघर्ष सोडवणे आवश्यक आहे, आणि त्यानंतरच वचनबद्धता पूर्ण करा. ठीक आहे. आम्ही मजकूर संपादकात विरोधाभास असलेली फाइल उघडतो आणि पहा: गिटने येथे काय केले हे समजून घेण्यासाठी, आम्ही कोणते बदल केले आणि कुठे केले हे लक्षात ठेवणे आवश्यक आहे आणि नंतर तुलना करा:

1. मास्टर ब्रँचमध्ये या ओळीवर असलेले बदल "<<<<<<< HEAD" आणि "=======" मध्ये आढळतात.
2. वैशिष्ट्य/अॅड-हेडर शाखेतील बदल "=======" आणि ">>>>>>> वैशिष्ट्य/अॅड-हेडर" मध्ये आढळतात.

अशाप्रकारे गिट आम्हाला सांगतो की फाइलमधील या स्थानावर विलीनीकरण कसे करावे हे समजू शकले नाही. याने हा विभाग वेगवेगळ्या शाखांमधून दोन भागात विभागला आहे आणि विलीनीकरणाचा संघर्ष स्वतः सोडवण्यासाठी आम्हाला आमंत्रित केले आहे. पुरेसा गोरा. मी धैर्याने सर्वकाही काढून टाकण्याचा निर्णय घेतो, फक्त "शीर्षलेख" शब्द सोडून: चला बदलांची स्थिती पाहू. वर्णन थोडे वेगळे असेल. "सुधारित" स्थितीऐवजी, आम्ही "अनमर्ज्ड" केले आहे. तर आपण पाचव्या स्थितीचा उल्लेख केला असता का? मला हे आवश्यक वाटत नाही. बघूया:

git status

आम्ही स्वतःला पटवून देऊ शकतो की ही एक विशेष, असामान्य केस आहे. चला सुरू ठेवूया:

git add *.txt

तुमच्या लक्षात येईल की वर्णन फक्त "गीट कमिट" लिहिण्यास सुचवते. चला ते लिहिण्याचा प्रयत्न करूया:

git commit

आणि त्याचप्रमाणे, आम्ही ते केले - आम्ही कन्सोलमधील संघर्षाचे निराकरण केले. अर्थात, एकात्मिक विकास वातावरणात हे थोडे सोपे केले जाऊ शकते. उदाहरणार्थ, IntelliJ IDEA मध्ये, सर्वकाही इतके चांगले सेट केले आहे की तुम्ही त्यामध्येच सर्व आवश्यक क्रिया करू शकता. पण IDEs "अंडर द हुड" बर्‍याच गोष्टी करतात आणि तिथे नेमके काय चालले आहे हे आपल्याला अनेकदा समजत नाही. आणि जेव्हा समज नसते तेव्हा समस्या उद्भवू शकतात.

रिमोट रेपॉजिटरीजसह कार्य करणे

शेवटची पायरी म्हणजे रिमोट रिपॉजिटरीसह कार्य करण्यासाठी आवश्यक असलेल्या आणखी काही कमांड्स शोधणे. मी म्हटल्याप्रमाणे, रिमोट रेपॉजिटरी ही अशी जागा आहे जिथे रेपॉजिटरी संग्रहित केली जाते आणि जिथून तुम्ही ते क्लोन करू शकता. कोणत्या प्रकारचे रिमोट रिपॉझिटरीज आहेत? उदाहरणे:

• GitHub हे रेपॉजिटरीज आणि सहयोगी विकासासाठी सर्वात मोठे स्टोरेज प्लॅटफॉर्म आहे. मी आधीच मागील लेखांमध्ये वर्णन केले आहे. GitHub
  वर माझे अनुसरण करा . ज्या क्षेत्रात मी कामाचा अभ्यास करत आहे त्या ठिकाणी मी अनेकदा माझे काम दाखवतो.

• GitLab हे ओपन सोर्ससह DevOps लाइफसायकलसाठी वेब-आधारित साधन आहे . ही एक Git- आधारित प्रणाली आहे जी स्वतःच्या विकी, बग ट्रॅकिंग सिस्टीम , CI/CD पाइपलाइन आणि इतर फंक्शन्ससह कोड रिपॉझिटरीज व्यवस्थापित करते . मायक्रोसॉफ्टने गिटहब विकत घेतल्याच्या बातमीनंतर, काही विकासकांनी त्यांचे प्रोजेक्ट गिटलॅबमध्ये डुप्लिकेट केले.
  

• बिटबकेट ही मर्क्युरियल आणि गिट आवृत्ती नियंत्रण प्रणालीवर आधारित प्रोजेक्ट होस्टिंग आणि सहयोगी विकासासाठी वेब सेवा आहे. एकेकाळी त्याचा गिटहबपेक्षा मोठा फायदा होता कारण तो विनामूल्य खाजगी भांडार देऊ करत होता. गेल्या वर्षी GitHub ने देखील ही क्षमता सर्वांना मोफत दिली होती.

• आणि असेच…

रिमोट रिपॉजिटरीसह काम करताना, सर्वप्रथम प्रकल्पाला तुमच्या स्थानिक भांडारात क्लोन करणे. यासाठी, आम्ही स्थानिक पातळीवर तयार केलेला प्रकल्प मी निर्यात केला आणि आता प्रत्येकजण लिहून स्वत: साठी क्लोन करू शकतो:

git clone https://github.com/romankh3/git-demo

आता प्रकल्पाची संपूर्ण स्थानिक प्रत आहे. प्रकल्पाची स्थानिक प्रत नवीनतम आहे याची खात्री करण्यासाठी, तुम्हाला लिहून प्रकल्प खेचणे आवश्यक आहे:

git pull

आमच्या बाबतीत, रिमोट रिपॉझिटरीमध्ये सध्या काहीही बदललेले नाही, म्हणून प्रतिसाद आहे: आधीच अद्ययावत. परंतु मी रिमोट रिपॉजिटरीमध्ये काही बदल केल्यास, आम्ही ते खेचल्यानंतर स्थानिक अपडेट केले जाते. आणि शेवटी, शेवटची आज्ञा म्हणजे डेटा रिमोट रिपॉजिटरीमध्ये ढकलणे. जेव्हा आम्ही स्थानिक पातळीवर काहीतरी केले आणि ते रिमोट रिपॉजिटरीमध्ये पाठवायचे असेल, तेव्हा आम्ही प्रथम स्थानिक पातळीवर नवीन कमिट तयार केले पाहिजे. हे दाखवण्यासाठी, आमच्या मजकूर फाइलमध्ये आणखी काहीतरी जोडूया: आता आमच्यासाठी एक सामान्य गोष्ट आहे - आम्ही या कामासाठी एक वचनबद्धता तयार करतो:

git add test_resource.txt
git commit -m "prepared txt for pushing"

हे रिमोट रिपॉजिटरीमध्ये ढकलण्याची आज्ञा आहे:

git push

बरं, मला एवढंच म्हणायचं होतं. तुमचे लक्ष दिल्याबद्दल धन्यवाद. GitHub वर माझे अनुसरण करा , जिथे मी माझ्या वैयक्तिक अभ्यास आणि कार्याशी संबंधित विविध छान उदाहरणे प्रोजेक्ट पोस्ट करतो.

उपयुक्त दुवा

• अधिकृत Git दस्तऐवजीकरण . मी एक संदर्भ म्हणून शिफारस करतो.