1. नवशिक्यांसाठी Git साठी तपशीलवार मार्गदर्शक

आज आपण Git नावाच्या आवृत्ती नियंत्रण प्रणालीबद्दल बोलणार आहोत.

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

Git मूलभूत

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

म्हणजेच, कोणत्या फायली बदलल्या आहेत आणि कशा बदलल्या आहेत हे आपल्याला चरण-दर-चरण पाहण्यास सक्षम असणे आवश्यक आहे. हे विशेषतः महत्वाचे आहे जेव्हा तुम्ही एका कार्याच्या संदर्भात काय बदलले आहे ते तपासत आहात, बदल परत करणे शक्य करते.

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

किंवा एकाच वेळी दोन विकसक त्यांच्या स्वतःच्या कोडमध्ये बदल करत असतील तर? Git शिवाय, ते मूळ कोड फायली कॉपी करतात आणि त्या स्वतंत्रपणे सुधारतात. अशी वेळ येते जेव्हा दोघांनाही त्यांचे बदल मुख्य निर्देशिकेत जोडायचे असतात. या प्रकरणात तुम्ही काय करता?

आपण Git वापरल्यास अशा कोणत्याही समस्या उद्भवणार नाहीत.

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

चला तुमच्या कॉम्प्युटरवर Java इन्स्टॉल करूया ही प्रक्रिया वेगवेगळ्या ऑपरेटिंग सिस्टिमसाठी थोडी वेगळी असते.

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

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

विंडोजवर, तुम्हाला गिट बॅश चालवावी लागेल. स्टार्ट मेनूमध्ये ते कसे दिसते ते येथे आहे:

आता हे कमांड प्रॉम्प्ट आहे ज्यावर तुम्ही काम करू शकता.

तेथे गिट उघडण्यासाठी प्रत्येक वेळी प्रोजेक्टसह फोल्डरमध्ये जाणे टाळण्यासाठी, आपण आवश्यक असलेल्या मार्गासह उजव्या माऊस बटणाने प्रोजेक्ट फोल्डरमध्ये कमांड प्रॉम्प्ट उघडू शकता:

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

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

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

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

येथे देखील, आपल्याला प्रथम Git तेथे आहे की नाही हे तपासण्याची आवश्यकता आहे (वर पहा, लिनक्स प्रमाणेच).

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

Git सेटिंग्ज

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

खालील आदेश चालवून तुमच्या सर्व प्रकल्पांसाठी वापरकर्तानाव आणि पासवर्ड सेट करा:

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

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

विषयात जाण्यासाठी, आम्ही तुम्हाला काही नवीन शब्द आणि कृतींची ओळख करून दिली पाहिजे... अन्यथा, बोलण्यासारखे काहीही राहणार नाही. अर्थात, हे इंग्रजीतून आम्हाला आलेले शब्दजाल आहे, म्हणून मी कंसात भाषांतर जोडेन.

कोणते शब्द आणि कृती?

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

वगैरे.

Git मधील स्थिती

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

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

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

आमच्या कोड असलेल्या फायलींना लागू होणारी ही स्थिती आहेत. दुसऱ्या शब्दांत, त्यांचे जीवन चक्र सहसा असे दिसते:

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

हे असे दिसते:

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

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

विशेषतः, प्रथम वचनबद्धता आहे. जेव्हा दुसरी कमिट तयार होते, तेव्हा पहिल्या नंतर काय येते हे (दुसऱ्याला) माहीत असते. आणि या पद्धतीने माहितीचा मागोवा घेता येतो.

कमिटची स्वतःची माहिती देखील असते, तथाकथित मेटाडेटा:

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

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

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

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

त्यानुसार, आम्ही असे म्हणू शकतो की समान कमिटकडे निर्देश करून तुम्हाला पाहिजे तितक्या शाखा असू शकतात.

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

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

तुम्ही स्थानिक रेपॉजिटरीसह एकट्या तसेच रिमोटसह कार्य करू शकता.

आवश्यक आदेशांचा सराव करण्यासाठी, तुम्ही स्वतःला स्थानिक भांडारात मर्यादित करू शकता. हे फक्त .git फोल्डरमध्ये सर्व प्रकल्पाची माहिती स्थानिकरित्या संग्रहित करते.

जर आपण रिमोट रेपॉजिटरीबद्दल बोलत असाल तर सर्व माहिती रिमोट सर्व्हरवर कुठेतरी संग्रहित केली जाते: प्रकल्पाची फक्त एक प्रत स्थानिकरित्या संग्रहित केली जाते. तुमच्या स्थानिक प्रतीमध्ये केलेले बदल रिमोट रिपॉझिटरीमध्ये (गिट पुश) ढकलले जाऊ शकतात.

येथे आणि खाली आमच्या चर्चेत, आम्ही कन्सोलमध्ये Git सह काम करण्याबद्दल बोलत आहोत. अर्थात, तुम्ही काही प्रकारचे GUI-आधारित सोल्यूशन वापरू शकता (उदाहरणार्थ, IntelliJ IDEA), परंतु प्रथम तुम्ही कोणते आदेश कार्यान्वित केले जात आहेत आणि त्यांचा अर्थ काय हे शोधून काढले पाहिजे.

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

स्थानिक भांडार तयार करण्यासाठी, तुम्हाला लिहावे लागेल:

हे कन्सोलच्या वर्तमान निर्देशिकेत लपलेले .git फोल्डर तयार करेल.

.git फोल्डर Git रेपॉजिटरीबद्दल सर्व माहिती संग्रहित करते. हटवू नका ;)

पुढे, फायली प्रकल्पात जोडल्या जातात आणि त्यांना "अनट्रॅक केलेले" स्थिती नियुक्त केली जाते. तुमच्या कामाची सद्यस्थिती तपासण्यासाठी, हे लिहा:

आम्ही मुख्य शाखेत आहोत, आणि आम्ही दुसर्‍या शाखेत जाईपर्यंत इथेच राहू.

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

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

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

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

येथे तुम्ही पाहू शकता की रेग्युलर एक्सप्रेशनने योग्यरित्या कार्य केले आहे: test_resource.txt ला आता "स्टेज" स्थिती आहे.

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

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

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

एक जिज्ञासू वाचक जो अद्याप झोपी गेला नाही तो कदाचित विचार करत असेल की GitTest.java फाइलचे काय झाले. चला आत्ताच शोधूया. हे करण्यासाठी, आम्ही वापरतो:

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

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

येथे तुम्ही "अनट्रॅक केलेले" आणि "सुधारित" स्थितींमधील फरक स्पष्टपणे पाहू शकता.

GitTest.java "अनट्रॅक केलेले" आहे, तर test_resource.txt "सुधारित" आहे.

आता आमच्याकडे फाईल्स सुधारित स्थितीत आहेत, आम्ही त्यात केलेले बदल तपासू शकतो. हे खालील आदेश वापरून केले जाऊ शकते:

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

चला मजकूर फाइलमध्ये आपले बदल जोडू आणि एक वचनबद्धता तयार करू:

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

तुम्ही बघू शकता, आमच्याकडे आता दोन कमिट आहेत.

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

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

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

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

या उदाहरणात, .gitignore फाइल यासारखी दिसेल:

चला पाहुया:

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

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

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

आता प्रोजेक्टमध्ये .gitignore फाईल जोडण्यासाठी कमिट वापरू.

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

आता आपण .gitignore फाईलचे इफेक्ट पाहावे:

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

शाखांसह काम करणे

साहजिकच, फक्त एका शाखेत काम करणे एकाकी विकसकांसाठी गैरसोयीचे असते आणि जेव्हा एका संघात एकापेक्षा जास्त व्यक्ती असतात तेव्हा ते अशक्य असते. त्यामुळे आमच्या शाखा आहेत.

शाखा म्हणजे कमिट करण्यासाठी फक्त एक जंगम पॉइंटर आहे.

या भागात, आम्ही वेगवेगळ्या शाखांमध्ये काम करणार आहोत: एका शाखेतून दुसऱ्या शाखेत बदल कसे विलीन करायचे, कोणते विवाद उद्भवू शकतात आणि बरेच काही.

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

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

नंतर शाखा तयार करण्यासाठी अनेक पर्याय आहेत (अजून काही असू शकतात - मी वापरतो ते हे आहेत):

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

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

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

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

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

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

आता आम्ही हे लिहून आमच्या शाखांचे पुन्हा पुनरावलोकन करू शकतो:

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

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

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

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

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

आता आम्ही मुख्य शाखेवर आधारित नवीन शाखा तयार करतो:

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

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

संघर्ष म्हणजे काय हे जाणून घेण्यापूर्वी, एक शाखा दुसऱ्या शाखेत विलीन करण्याबद्दल बोलणे आवश्यक आहे.

हे चित्र एका शाखेला दुसऱ्या शाखेत विलीन करण्याची प्रक्रिया दर्शवते:

येथे आमची मुख्य शाखा आहे. काही ठिकाणी, मुख्य शाखेच्या बाहेर दुय्यम शाखा तयार केली जाते आणि नंतर सुधारित केली जाते. काम पूर्ण झाल्यावर, आम्हाला एक शाखा दुसर्‍यामध्ये विलीन करण्याची आवश्यकता आहे.

आमच्या उदाहरणात, आम्ही वैशिष्ट्य/अपडेट-txt-फाईल्स शाखा तयार केली. शाखेच्या नावाने सूचित केल्याप्रमाणे, आम्ही मजकूर अद्यतनित करत आहोत.

आता आपल्याला या कामासाठी नवीन कमिट तयार करण्याची आवश्यकता आहे:

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

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

ही कार्यक्षमता जोडली गेली, त्यामुळे तुम्ही वैशिष्ट्य शाखा हटवू शकता. हे करण्यासाठी, आम्ही लिहितो:

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

आम्ही मास्टरवर आधारित नवीन शाखा तयार करू, text_resource.txt मध्ये बदल करू आणि या कामासाठी एक वचनबद्धता तयार करू:

... आम्ही फाइलमध्ये बदल करतो

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

… आम्ही test_resource.txt अपडेट केले

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

परंतु परिणाम test_resource.txt फाइलमध्ये विरोधाभास होईल:

येथे आपण पाहू शकतो की हा कोड कसा विलीन करायचा हे गिट स्वतः ठरवू शकत नाही. हे आम्हाला सांगते की आपण प्रथम संघर्ष सोडवणे आवश्यक आहे, आणि त्यानंतरच वचनबद्धता पूर्ण करा.

ठीक आहे. आम्ही मजकूर संपादकामध्ये विरोधासह फाइल उघडतो आणि पहा:

गिटने येथे काय केले हे समजून घेण्यासाठी, आम्ही कोणते बदल केले आणि कुठे केले हे लक्षात ठेवणे आवश्यक आहे आणि नंतर तुलना करा:

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

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

पुरेसा गोरा. फक्त "शीर्षलेख" हा शब्द सोडून मी धैर्याने सर्वकाही काढून टाकण्याचा निर्णय घेतो:

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

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

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

आणि त्याचप्रमाणे, आम्ही ते केले - आम्ही कन्सोलमधील संघर्षाचे निराकरण केले.

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

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

शेवटची पायरी म्हणजे रिमोट रिपॉजिटरीसह कार्य करण्यासाठी आवश्यक असलेल्या आणखी काही कमांड्स शोधणे.

मी म्हटल्याप्रमाणे, रिमोट रेपॉजिटरी ही अशी जागा आहे जिथे रेपॉजिटरी संग्रहित केली जाते आणि जिथून तुम्ही ते क्लोन करू शकता.

कोणत्या प्रकारचे रिमोट रिपॉझिटरीज आहेत? उदाहरणे:

• GitHub हे रेपॉजिटरीज आणि सहयोगी विकासासाठी सर्वात मोठे स्टोरेज प्लॅटफॉर्म आहे.
• GitLab हे ओपन सोर्ससह DevOps लाइफसायकलसाठी वेब-आधारित साधन आहे. कोड रिपॉझिटरीज व्यवस्थापित करण्यासाठी ही एक Git-आधारित प्रणाली आहे ज्याचे स्वतःचे विकी, बग ट्रॅकिंग सिस्टम, CI/CD पाइपलाइन आणि इतर कार्ये आहेत.
• बिटबकेट ही मर्क्युरियल आणि गिट आवृत्ती नियंत्रण प्रणालीवर आधारित प्रोजेक्ट होस्टिंग आणि सहयोगी विकासासाठी वेब सेवा आहे. एकेकाळी त्याचा गिटहबपेक्षा मोठा फायदा होता कारण तो विनामूल्य खाजगी भांडार देऊ करत होता. गेल्या वर्षी GitHub ने देखील ही क्षमता सर्वांना मोफत दिली होती.
• आणि असेच…

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

यासाठी, आम्ही स्थानिक पातळीवर तयार केलेला प्रकल्प आम्ही निर्यात केला आहे आता प्रत्येकजण स्वत: साठी लिहून क्लोन करू शकतो:

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

आमच्या बाबतीत, रिमोट रिपॉझिटरीमध्ये सध्या काहीही बदललेले नाही, म्हणून प्रतिसाद आहे: आधीच अद्ययावत.

परंतु आम्ही रिमोट रिपॉझिटरीमध्ये काही बदल केल्यास, आम्ही ते खेचल्यानंतर स्थानिक अपडेट केले जाते.

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

आता आमच्यासाठी काहीतरी सामान्य आहे - आम्ही या कामासाठी एक वचनबद्धता तयार करतो:

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

आतासाठी एवढेच!

2. IntelliJ IDEA मध्ये Git सह कसे कार्य करावे

या भागात, तुम्ही IntelliJ IDEA मध्ये Git सह कसे काम करावे ते शिकाल.

आवश्यक इनपुट:

1. मागील भाग वाचा, अनुसरण करा आणि समजून घ्या. हे सर्व काही सेट केले आहे आणि जाण्यासाठी तयार आहे याची खात्री करण्यात मदत करेल.
2. IntelliJ IDEA स्थापित करा. येथे सर्व काही व्यवस्थित असावे :)
3. पूर्ण प्रभुत्व मिळविण्यासाठी एक तास द्या.

मी Git बद्दलच्या लेखासाठी वापरलेल्या डेमो प्रोजेक्टसह काम करूया .

स्थानिक पातळीवर प्रकल्प क्लोन करा

येथे दोन पर्याय आहेत:

1. तुमच्याकडे आधीपासून गिटहब खाते असल्यास आणि नंतर काहीतरी पुश करायचे असल्यास, प्रोजेक्ट फोर्क करणे आणि स्वतःची कॉपी क्लोन करणे चांगले. फोर्किंग वर्कफ्लोचे उदाहरण या शीर्षकाखाली दुसर्‍या लेखात काटा कसा तयार करायचा याबद्दल तुम्ही वाचू शकता .
2. रेपॉजिटरी क्लोन करा आणि सर्व काही सर्व्हरवर ढकलण्याच्या क्षमतेशिवाय स्थानिक पातळीवर करा.

GitHub वरून प्रोजेक्ट क्लोन करण्यासाठी, तुम्हाला प्रोजेक्ट लिंक कॉपी करून IntelliJ IDEA ला पास करणे आवश्यक आहे:

1. प्रकल्प पत्ता कॉपी करा:

2. IntelliJ IDEA उघडा आणि "आवृत्ती नियंत्रणातून मिळवा" निवडा:

3. प्रकल्प पत्ता कॉपी आणि पेस्ट करा:

4. तुम्हाला IntelliJ IDEA प्रकल्प तयार करण्यास सांगितले जाईल. ऑफर स्वीकारा:

5. कोणतीही बिल्ड सिस्टम नसल्यामुळे, आम्ही "विद्यमान स्रोतांमधून प्रकल्प तयार करा" निवडतो:

6. पुढे तुम्हाला ही सुंदर स्क्रीन दिसेल:

आता आम्ही क्लोनिंग शोधले आहे, तुम्ही आजूबाजूला एक नजर टाकू शकता.

Git UI म्हणून IntelliJ IDEA वर प्रथम दृष्टीक्षेप

क्लोन केलेल्या प्रकल्पावर बारकाईने नजर टाका: आपण आधीपासूनच आवृत्ती नियंत्रण प्रणालीबद्दल बरीच माहिती मिळवू शकता.

प्रथम, आमच्याकडे खालच्या डाव्या कोपर्यात आवृत्ती नियंत्रण उपखंड आहे. येथे तुम्ही सर्व स्थानिक बदल शोधू शकता आणि कमिटची सूची मिळवू शकता ("गिट लॉग" प्रमाणे).

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

शिवाय, आपण वास्तविक बदल पाहू शकता. तेथे संघर्ष मिटल्याचेही आपण पाहतो. IDEA देखील हे खूप चांगले सादर करते.

या कमिट दरम्यान बदललेल्या फाईलवर तुम्ही डबल-क्लिक केल्यास, संघर्ष कसा सोडवला गेला ते आम्ही पाहू:

आम्ही लक्षात घेतो की डावीकडे आणि उजवीकडे आमच्याकडे एकाच फाईलच्या दोन आवृत्त्या आहेत ज्या एकामध्ये विलीन करणे आवश्यक आहे. आणि मध्यभागी, आमच्याकडे अंतिम विलीन परिणाम आहे.

जेव्हा प्रोजेक्टमध्ये अनेक शाखा, कमिट आणि वापरकर्ते असतात, तेव्हा तुम्हाला शाखा, वापरकर्ता आणि तारखेनुसार स्वतंत्रपणे शोधण्याची आवश्यकता असते:

सुरुवात करण्यापूर्वी, आपण कोणत्या शाखेत आहोत हे कसे समजून घ्यावे हे स्पष्ट करणे देखील फायदेशीर आहे.

खालच्या उजव्या कोपर्यात, "Git: master" असे लेबल केलेले बटण आहे. "गिट:" चे अनुसरण करणारी कोणतीही वर्तमान शाखा आहे. तुम्ही बटणावर क्लिक केल्यास, तुम्ही अनेक उपयुक्त गोष्टी करू शकता: दुसर्‍या शाखेत जा, नवीन शाखा तयार करा, अस्तित्वात असलेल्या शाखेचे नाव बदला, इत्यादी.

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

उपयुक्त हॉटकीज

भविष्यातील कामासाठी, आपल्याला काही अतिशय उपयुक्त हॉटकी लक्षात ठेवण्याची आवश्यकता आहे:

1. CTRL+T — रिमोट रिपॉझिटरी (गिट पुल) मधून नवीनतम बदल मिळवा.
2. CTRL+K - एक कमिट तयार करा / सध्याचे सर्व बदल पहा. यामध्ये ट्रॅक न केलेल्या आणि सुधारित फाइल्स (गिट कमिट) दोन्ही समाविष्ट आहेत.
3. CTRL+SHIFT+K — रिमोट रिपॉझिटरीमध्ये बदल पुश करण्यासाठी ही कमांड आहे. स्थानिक पातळीवर तयार केलेल्या आणि अद्याप रिमोट रिपॉझिटरीमध्ये नसलेल्या सर्व कमिट पुश केल्या जातील (गिट पुश).
4. ALT+CTRL+Z — स्थानिक रेपॉजिटरीमध्ये तयार केलेल्या शेवटच्या कमिटच्या स्थितीत विशिष्ट फाइलमधील रोलबॅक बदल. तुम्ही वरच्या डाव्या कोपर्‍यात संपूर्ण प्रकल्प निवडल्यास, तुम्ही सर्व फायलींमधील बदल परत करू शकता.

आम्हाला काय हवे आहे?

काम पूर्ण करण्यासाठी, आम्हाला सर्वत्र वापरल्या जाणार्‍या मूलभूत परिस्थितीवर प्रभुत्व मिळवणे आवश्यक आहे.

एका वेगळ्या शाखेत नवीन कार्यक्षमता लागू करणे आणि नंतर त्यास रिमोट रिपॉझिटरीमध्ये ढकलणे हे उद्दिष्ट आहे (मग तुम्हाला मुख्य शाखेला पुल विनंती देखील तयार करण्याची आवश्यकता आहे, परंतु ते या धड्याच्या व्याप्तीच्या बाहेर आहे).

हे करण्यासाठी काय आवश्यक आहे?

1. मुख्य शाखेतील सर्व वर्तमान बदल मिळवा (उदाहरणार्थ, "मास्टर").

2. या मुख्य शाखेतून तुमच्या कामासाठी वेगळी शाखा तयार करा.

3. नवीन कार्यक्षमता लागू करा.

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

   तुम्ही विचार करत आहात की तुम्ही हे का करावे? हे चांगले शिष्टाचार आहे आणि तुमची शाखा स्थानिक भांडारात ढकलल्यानंतर संघर्ष होण्यापासून प्रतिबंधित करते (अर्थातच, तरीही संघर्ष होण्याची शक्यता आहे, परंतु ते खूपच लहान होते).

5. रिमोट रिपॉजिटरीमध्ये तुमचे बदल पुश करा.

रिमोट सर्व्हरवरून बदल कसे मिळवायचे?

आम्ही नवीन वचनबद्धतेसह README मध्ये वर्णन जोडले आहे आणि हे बदल मिळवू इच्छितो. स्थानिक रिपॉझिटरी आणि रिमोटमध्ये दोन्ही बदल केले असल्यास, आम्हाला विलीनीकरण आणि रिबेस दरम्यान निवडण्यासाठी आमंत्रित केले आहे. आम्ही विलीन करणे निवडतो.

CTRL+T प्रविष्ट करा :

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

मास्टरवर आधारित नवीन शाखा तयार करा

येथे सर्व काही सोपे आहे.

तळाशी उजव्या कोपर्यात जा आणि Git: master वर क्लिक करा . + नवीन शाखा निवडा .

चेकआउट शाखा चेकबॉक्स निवडलेला सोडा आणि नवीन शाखेचे नाव प्रविष्ट करा. आमच्या बाबतीत: हे रीडमी-इम्प्रोव्हर असेल .

Git: master नंतर Git: readme-improver मध्ये बदलेल .

चला समांतर कामाचे अनुकरण करूया

संघर्ष दिसण्यासाठी, कोणीतरी ते तयार केले पाहिजेत.

आम्ही ब्राउझरद्वारे नवीन कमिटसह README संपादित करू, अशा प्रकारे समांतर कामाचे अनुकरण करू. आम्ही काम करत असताना त्याच फाईलमध्ये कोणीतरी बदल केल्यासारखे आहे. परिणामी संघर्ष होईल. आम्ही 10 व्या ओळीतून "fully" हा शब्द काढून टाकू.

आमची कार्यक्षमता लागू करा

आमचे कार्य README बदलणे आणि नवीन लेखात वर्णन जोडणे आहे. म्हणजेच Git मधील काम IntelliJ IDEA द्वारे होते. हे जोडा:

बदल केले जातात. आता आपण कमिट तयार करू शकतो. CTRL+K दाबा , जे आम्हाला देते:

कमिट तयार करण्यापूर्वी, आम्हाला ही विंडो काय ऑफर करते यावर बारकाईने लक्ष देणे आवश्यक आहे.

कमिट मेसेज विभागात , आम्ही कमिटशी संबंधित मजकूर लिहितो. नंतर ते तयार करण्यासाठी, आम्हाला Commit वर क्लिक करावे लागेल .

आम्ही लिहितो की README बदलला आहे आणि कमिट तयार करा. कमिटच्या नावासह खालच्या डाव्या कोपर्यात एक अलर्ट पॉप अप होईल:

मुख्य शाखा बदलली आहे का ते तपासा

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

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

मुख्य शाखेत, रिमोट सर्व्हरवरून नवीनतम बदल मिळविण्यासाठी CTRL+T दाबा. काय बदल झाले ते पाहता, काय झाले ते तुम्ही सहज पाहू शकता:

"fully" हा शब्द काढला. कदाचित मार्केटिंगमधील कोणीतरी असे लिहायचे नाही असे ठरवले आणि विकसकांना ते अद्यतनित करण्याचे कार्य दिले.

आमच्याकडे आता मास्टर शाखेच्या नवीनतम आवृत्तीची स्थानिक प्रत आहे. readme-improver वर परत जा .

आता आपल्याला मास्टर ब्रँचमधून आमच्या शाखेतील बदलांची पुनर्बांधणी करायची आहे. आम्ही हे करतो:

जर तुम्ही सर्वकाही योग्यरित्या केले असेल आणि माझ्याबरोबर अनुसरण केले असेल, तर परिणाम README फाइलमध्ये विरोध दर्शवेल:

इथे आपल्याला समजण्यासाठी आणि भिजवण्यासारखी बरीच माहिती आहे. विरोधाभास असलेल्या फाइल्सची सूची (आमच्या बाबतीत, एक फाइल) येथे दर्शविली आहे. आम्ही तीन पर्यायांमधून निवडू शकतो:

1. तुमचा स्वीकार करा — फक्त readme-improver कडून बदल स्वीकारा.
2. त्यांचा स्वीकार करा - केवळ मास्टरकडून बदल स्वीकारा.
3. विलीन करा — तुम्हाला काय ठेवायचे आहे आणि काय टाकायचे आहे ते स्वतः निवडा.

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

येथे आपण पाहू शकतो की तीन भाग आहेत:

1. हे readme-improver मधील बदल आहेत.
2. एकत्रित परिणाम. सध्या, बदलांपूर्वी तेच अस्तित्वात होते.
3. मुख्य शाखेतील बदल.

आम्हाला एक विलीन केलेला परिणाम तयार करण्याची आवश्यकता आहे जो प्रत्येकाला संतुष्ट करेल. आमच्या बदलांपूर्वी काय बदलले होते याचे पुनरावलोकन करताना, आम्हाला जाणवते की त्यांनी फक्त "fully" हा शब्द काढून टाकला. ठीक आहे, काही हरकत नाही! याचा अर्थ असा की आम्ही विलीन केलेल्या निकालामध्ये ते काढून टाकू आणि नंतर आमचे बदल जोडू. एकदा आम्ही विलीन केलेला निकाल दुरुस्त केल्यानंतर, आम्ही लागू करा क्लिक करू शकतो .

नंतर एक सूचना पॉप अप होईल, आम्हाला सांगेल की रीबेस यशस्वी झाला:

तेथे! आम्ही आमचा पहिला संघर्ष IntelliJ IDEA द्वारे सोडवला.

रिमोट सर्व्हरवर बदल पुश करा

पुढील पायरी म्हणजे रिमोट सर्व्हरवर बदल पुश करणे आणि पुल विनंती तयार करणे. हे करण्यासाठी, फक्त CTRL+SHIFT+K दाबा . मग आम्हाला मिळते:

डावीकडे, रिमोट रिपॉझिटरीमध्ये न ढकलल्या गेलेल्या कमिटची यादी असेल. उजवीकडे बदललेल्या सर्व फाईल्स असतील. आणि तेच! पुश दाबा आणि तुम्हाला आनंदाचा अनुभव येईल :)

पुश यशस्वी झाल्यास, तुम्हाला खालील उजव्या कोपर्यात अशी सूचना दिसेल:

बोनस: पुल विनंती तयार करणे

चला GitHub रेपॉजिटरी वर जाऊ आणि आम्ही पाहतो की GitHub ला आधीच माहित आहे की आम्हाला काय हवे आहे:

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

आतासाठी एवढेच!