Git سان شروع ڪرڻ: شروعات ڪندڙن لاءِ تفصيلي گائيڊ

تعارف جي بدران

هيلو مستقبل جو سينيئر سافٽ ويئر انجنيئر. اڄ اسين ورجن ڪنٽرول سسٽم جي باري ۾ ڳالهائينداسين، يعني Git (پڙهو جيئن GIT، ۽ نه JIT، جيئن اهو انگريزي گرامر مان لڳي سگهي ٿو). ها، ها، مان ڄاڻان ٿو ته هتي مرڪيوريل، SVN پڻ آهي ... پر اچو ته ايماندار ٿي وڃو: انهن جو وقت گذري چڪو آهي، ۽ مان توهان جو قيمتي وقت انهن تي ضايع ڪرڻ وارو نه آهيان. انهي ڪري ته توهان اسان جي وقت ۾ گٽ کي ڄاڻڻ جي اهميت کي سمجهي، مان هي چوندس: هن جي ڄاڻ/سمجهڻ کان سواء، توهان کي پروگرامنگ ۾ ڪرڻ لاء ڪجهه به ناهي. پر خوبصورتي اها آهي ته مسلسل ڪم ڪرڻ لاءِ توهان کي پنهنجي سر ۾ سڀني حڪمن ۽ امڪانن کي رکڻ جي ضرورت ناهي. توهان کي ڄاڻڻ جي ضرورت آهي حڪمن جو هڪ سيٽ جيڪو توهان جي هر شيء کي سمجهڻ ۾ مدد ڪندو جيڪو ٿي رهيو آهي.

گيٽ بنياديات

Git اسان جي ڪوڊ لاء ورهايل ورزن ڪنٽرول سسٽم آهي. اسان کي ان جي ضرورت ڇو آهي؟ ورهايل ٽيمن کي ڪجهه قسم جي ڪم مينيجمينٽ سسٽم جي ضرورت آهي. تبديلين کي ٽريڪ ڪرڻ جي ضرورت آهي جيڪي وقت سان ٿينديون آهن. اھو آھي، قدم بہ قدم اسان ڏسون ٿا ڪھڙي فائلون تبديل ٿي ويون آھن ۽ ڪيئن. اهو خاص طور تي اهم آهي جڏهن توهان تجزيو ڪيو ته هڪ ڪم ۾ ڇا ڪيو ويو آهي: اهو واپس وڃڻ ممڪن بڻائي ٿو. اچو ته ھڪڙي صورتحال جو تصور ڪريو: ھڪڙو ڪم ڪندڙ ڪوڊ ھو، ان ۾ سڀ ڪجھ سٺو ھو، پر اسان ڪجھھ بھتر ڪرڻ جو فيصلو ڪيو، ان کي هتي ٽائيڪ ڪريو، ان کي اتي ٽائيڪ ڪريو. هر شي ٺيڪ هئي، پر هن سڌاري ڪارڪردگي جو اڌ ڀڃي ڇڏيو ۽ اهو ڪم ڪرڻ ناممڪن بڻائي ڇڏيو. پوء، اڳتي ڇا آهي؟ گيتا جي بغير، ڪنهن کي ڪلاڪن تائين ويهڻو پوندو ۽ ياد رکڻ گهرجي ته سڀ ڪجهه اصل ۾ ڪيئن هو. ۽ تنهنڪري اسان صرف ڪمٽ ڏانهن واپس وڃون ٿا ۽ اهو ئي آهي. يا ڇا جيڪڏهن اتي ٻه ڊولپرز هڪ ئي وقت پنهنجو ڪوڊ تبديل ڪري رهيا آهن؟ گٽ کان سواءِ اهو هن طرح ڏسڻ ۾ اچي ٿو: انهن ڪوڊ کي اصل مان نقل ڪيو ۽ اهو ڪيو جيڪو انهن کي ڪرڻو هو. اهو لمحو اچي ٿو ۽ ٻئي چاهيو ٿا انهن جي تبديلين کي مکيه فولڊر ۾ شامل ڪريو. ۽ هن حالت ۾ ڇا ڪجي؟... مون کي اهو ڪم ڪرڻ جي وقت جو اندازو لڳائڻ جي همت ناهي. جيڪڏهن توهان Git استعمال ڪريو ته اهڙي ڪا به پريشاني نه هوندي.

Git انسٽال ڪرڻ

اچو ته توهان جي ڪمپيوٽر تي Git انسٽال ڪريون. مان سمجهان ٿو ته هرڪو مختلف OS آهي، تنهنڪري مان ڪيترن ئي ڪيسن لاء بيان ڪرڻ جي ڪوشش ڪندس.

ونڊوز لاء انسٽاليشن

عام طور تي، توهان کي exe فائل ڊائون لوڊ ڪرڻ ۽ ان کي هلائڻ جي ضرورت آهي. هتي سڀ ڪجھ سادو آهي: پهرين گوگل لنڪ تي ڪلڪ ڪريو ، انسٽال ڪريو ۽ بس. ڪم لاءِ اسان استعمال ڪنداسين بش ڪنسول جيڪي اهي مهيا ڪندا آهن. ونڊوز تي ڪم ڪرڻ لاءِ، توھان کي ھلڻو پوندو Git Bash. اھو اھو آھي جيڪو اھو ڏسڻ ۾ اچي ٿو شروعاتي مينيو ۾: ۽ اھو اڳ ۾ ئي ھڪڙو ڪنسول آھي جنھن ۾ توھان ڪم ڪري سگھو ٿا. پراجيڪٽ سان فولڊر ۾ نه وڃڻ لاءِ هر دفعي گٽ کولڻ لاءِ اتي ، توهان فولڊر ۾ ساڄي ڪلڪ ڪري سگهو ٿا ڪنسول کولڻ لاءِ جنهن رستي جي اسان کي ضرورت آهي:

لينڪس لاء انسٽاليشن

عام طور تي git اڳ ۾ ئي انسٽال ٿيل آهي ۽ لينڪس جي تقسيم ۾ شامل آهي، ڇاڪاڻ ته اهو هڪ اوزار آهي جيڪو اصل ۾ لينڪس ڪنييل کي ترقي ڪرڻ لاء لکيو ويو آهي. پر اتي حالتون آهن جڏهن اهو موجود ناهي. هن کي چيڪ ڪرڻ لاء، توهان کي ٽرمينل کولڻ جي ضرورت آهي ۽ ٽائپ ڪريو: git --version. جيڪڏهن ڪو واضح جواب آهي، ته ڪا به شيء انسٽال ڪرڻ جي ڪا ضرورت ناهي. هڪ ٽرمينل کوليو ۽ انسٽال ڪريو. مان Ubuntu تي ڪم ڪريان ٿو، تنهنڪري مان توهان کي ٻڌائي سگهان ٿو ته ان لاءِ ڇا لکجي: sudo apt-get install git. ۽ اھو اھو آھي: ھاڻي توھان استعمال ڪري سگھوٿا Git ڪنھن ٽرمينل ۾.

macOS تي انسٽاليشن

هتي، پڻ، پهرين توهان کي چيڪ ڪرڻ جي ضرورت آهي ته ڇا Git اڳ ۾ ئي موجود آهي (مٿي ڏسو، لينڪس تي). جيڪڏهن نه، سڀ کان آسان طريقو جديد نسخو ڊائون لوڊ ڪرڻ آهي . جيڪڏهن XCode انسٽال ٿيل آهي، ته پوءِ 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 فولڊر ۾ محفوظ ڪري ٿو. جيڪڏهن اسان ريموٽ جي باري ۾ ڳالهايون ٿا، ته پوء سموري معلومات ريموٽ سرور تي محفوظ ڪئي وئي آهي: صرف پروجيڪٽ جي هڪ ڪاپي مقامي طور تي ذخيرو ٿيل آهي، جنهن ۾ تبديليون (گٽ پش) ريموٽ مخزن ڏانهن ڌڪي سگهجن ٿيون. هتي ۽ اڳتي اسان بحث ڪنداسين گٽ سان ڪم ڪرڻ ڪنسول ۾. يقينا، توهان ڪجهه گرافڪ حل استعمال ڪري سگهو ٿا (مثال طور، Intellij IDEA ۾)، پر پهريان توهان کي اهو ڄاڻڻ جي ضرورت آهي ته ڪهڙا حڪم ٿي رهيا آهن ۽ انهن جو مطلب ڇا آهي.

Git سان مقامي مخزن ۾ ڪم ڪرڻ

اڳيون، مان مشورو ڏيان ٿو ته توهان سڀني قدمن تي عمل ڪريو جيڪي مون ڪيا هئا جڏهن توهان مضمون پڙهي رهيا آهيو. اهو توهان جي سمجھڻ ۽ مواد جي برقرار رکڻ کي بهتر بڻائيندو. سو bon appetit :) مقامي مخزن ٺاهڻ لاءِ، توھان کي لکڻو پوندو:

git init

اهو هڪ .git فولڊر ٺاهيندو ان هنڌ تي جتي ڪنسول واقع آهي. .git هڪ فولڊر آهي جيڪو Git مخزن جي باري ۾ سڀني معلومات کي محفوظ ڪري ٿو. ان کي ختم ڪرڻ جي ڪا ضرورت ناهي؛) اڳتي هلي، فائلون هن پروجيڪٽ ۾ شامل ڪيون وينديون آهن، ۽ انهن جي اسٽيٽس Untracked ٿي ويندي آهي. ڏسڻ لاءِ موجوده ڪم جي حالت ڇا آهي، لکو:

git status

اسان ماسٽر برانچ ۾ آهيون، ۽ جيستائين اسان ٻئي ڏانهن نه وڃون، سڀ ڪجهه ائين ئي رهندو. اهو طريقو توهان ڏسي سگهو ٿا ته ڪهڙيون فائلون تبديل ڪيون ويون آهن پر اڃا تائين اسٽيج ٿيل رياست ۾ شامل نه ڪيو ويو آهي. انهن کي اسٽيج ٿيل رياست ۾ شامل ڪرڻ لاءِ، توهان کي لکڻ جي ضرورت آهي git add. هتي ڪيترائي اختيار ٿي سگھن ٿا، مثال طور:

• git add -A - اسٽيج ٿيل رياست مان سڀئي فائلون شامل ڪريو؛
• git شامل ڪريو. - شامل ڪريو سڀ فائلون ھن فولڊر مان ۽ سڀ اندروني فائلون. لازمي طور تي اڳئين هڪ وانگر؛
• git add <filename> - صرف هڪ مخصوص فائل شامل ڪري ٿو. هتي توهان ڪجهه نموني مطابق شامل ڪرڻ لاء باقاعده اظهار استعمال ڪري سگهو ٿا. مثال طور، 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 غير ٽريڪ ٿيل حالت ۾ آھي ۽ 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 سان ڪم ڪرڻ

اهو واضح آهي ته اسان صرف سورس ڪوڊ کي ذخيرو ڪرڻ چاهيون ٿا ۽ مخزن ۾ ٻيو ڪجهه به ناهي. ٻيو ڇا ٿي سگهي ٿو؟ گهٽ ۾ گهٽ، مرتب ڪيل ڪلاس ۽/يا فائلون جيڪي ٺاهين ٿيون ترقيءَ جو ماحول. Git لاءِ انھن کي نظر انداز ڪرڻ لاءِ، ھڪڙو خاص فائل آھي جنھن کي ٺاھيو وڃي. اسان هي ڪندا آهيون: اسان پروجيڪٽ جي روٽ ۾ هڪ فائل ٺاهيندا آهيون جنهن کي .gitignore سڏيو ويندو آهي، ۽ هن فائل ۾ هر لڪير کي نظر انداز ڪرڻ جو نمونو هوندو. هن مثال ۾، git ignore هن طرح نظر ايندو:

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

اچو ته هاڻي ڏسون:

• پهرين لڪير سڀني فائلن کي .clاس ايڪسٽينشن سان نظرانداز ڪرڻ آهي؛
• ٻئين لڪير کي نظر انداز ڪرڻ آهي ٽارگيٽ فولڊر ۽ ان ۾ موجود هر شيءِ؛
• ٽين لائين .iml ايڪسٽينشن سان سڀني فائلن کي نظرانداز ڪرڻ آهي.
• چوٿين لائن .idea فولڊر کي نظرانداز ڪرڻ آهي.

اچو ته ان کي هڪ مثال سان ڪوشش ڪريون. ڏسڻ لاءِ ته هي ڪيئن ڪم ڪري ٿو، مرتب ڪيل GitTest.class ڪلاس کي پروجيڪٽ ۾ شامل ڪريو ۽ پروجيڪٽ جي صورتحال ڏسو:

git status

واضح طور تي، اسان حادثاتي طور تي نٿا چاهيون (جيڪڏهن اسان استعمال ڪندا آهيون git add -A) پروجيڪٽ ۾ مرتب ڪيل ڪلاس شامل ڪريو. هن کي ڪرڻ لاءِ، هڪ .gitignore فائل ٺاهيو ۽ هر شي شامل ڪريو جيڪا اڳ بيان ڪئي وئي هئي: هاڻي اچو ته شامل ڪريون git ignore منصوبي ۾ نئين ڪمٽ سان:

git add .gitignore
git commit -m “added .gitignore file”

۽ ھاڻي سچ جو لمحو: اسان وٽ ھڪڙو مرتب ڪيل GitTest.class ڪلاس آھي ھڪڙي غير محفوظ حالت ۾، جنھن کي اسان گٽ مخزن ۾ شامل ڪرڻ نٿا چاھيو. هي آهي جتي git نظرانداز ڪم ڪرڻ گهرجي:

git status

هر شي واضح آهي) Git نظرانداز +1)

شاخن ۽ ٻين سان ڪم ڪرڻ

يقينا، هڪ شاخ ۾ ڪم ڪرڻ هڪ لاء تڪليف ۽ ناممڪن آهي جڏهن ٽيم ۾ هڪ کان وڌيڪ ماڻهو آهن. هن لاء هڪ شاخ آهي. جيئن مون اڳ ۾ چيو، هڪ شاخ صرف ڪم ڪرڻ لاء هڪ حرڪت وارو اشارو آهي. هن حصي ۾، اسان مختلف شاخن ۾ ڪم ڪرڻ تي نظر ڪنداسين: تبديلين کي هڪ شاخ کان ٻي شاخ ۾ ڪيئن ضم ڪرڻ، ڪهڙو تڪرار پيدا ٿي سگهي ٿو، ۽ گهڻو ڪجهه. مخزن ۾ سڀني شاخن جي فهرست ڏسڻ لاءِ ۽ سمجھو ته توھان ڪھڙي تي آھيو، توھان کي لکڻو پوندو:

git branch -a

توهان ڏسي سگهو ٿا ته اسان وٽ صرف هڪ ماسٽر برانچ آهي، ۽ ان جي سامهون ستاري چوي ٿو ته اسان ان تي آهيون. رستي ۾، اهو معلوم ڪرڻ لاء ته اسان ڪهڙي برانچ تي آهيون، اسان پڻ استعمال ڪري سگهون ٿا اسٽيٽس چيڪ (گٽ اسٽيٽس). اڳيون، شاخون ٺاهڻ لاء ڪيترائي اختيار آھن (شايد اتي وڌيڪ آھن، مان ھي استعمال ڪريان ٿو):

• ھڪڙي نئين شاخ ٺاھيو جنھن تي اسان آھيون (99٪ ڪيس)؛
• ھڪڙي شاخ ٺاھيو ھڪڙي مخصوص عزم جي بنياد تي (1٪).

ھڪڙي مخصوص وابستگي جي بنياد تي ھڪڙي شاخ ٺاھيو

اسان انحصار ڪنداسين منفرد عزم جي سڃاڻپ ڪندڙ تي. ان کي ڳولڻ لاء، اسان لکندا آهيون:

git log

مون تبصري سان عزم کي اجاگر ڪيو ”شامل هيلو ورلڊ...“. اهو هڪ منفرد سڃاڻپ ڪندڙ آهي - "6c44e53d06228f888f2f454d3cb8c1c976dd73f8". مان هن انجام کان شروع ٿيندڙ هڪ ترقياتي شاخ ٺاهڻ چاهيان ٿو. ان لاءِ مان لکندس:

git checkout -b development 6c44e53d06228f888f2f454d3cb8c1c976dd73f8

ھڪڙي شاخ ٺاھي وئي آھي جنھن ۾ ماسٽر برانچ مان صرف پھريون ٻه ڪميون شامل آھن. هن کي جانچڻ لاءِ، اسان پهريان پڪ ڪنداسين ته اسان ٻئي برانچ ڏانهن ويا آهيون ۽ ان تي ڪيل ڪمن جو تعداد ڏسو:

git status
git log

۽ اهو سچ آهي: اهو ظاهر ٿيو ته اسان وٽ ٻه واعدو آهن. رستي ۾، هڪ دلچسپ نقطو: هن برانچ ۾ اڃا تائين ڪا به .gitignore فائل نه آهي، تنهنڪري اسان جي مرتب ڪيل فائل (GitTest.class) هاڻي غير محفوظ حالت ۾ نمايان ڪئي وئي آهي. هاڻي اسان پنهنجي برانچن کي ٻيهر لکي سگھون ٿا:

git branch -a

اهو ڏسي سگهجي ٿو ته ٻه شاخون آهن - ماسٽر ۽ ترقي - ۽ هاڻي اسان ترقي تي آهيون.

موجوده ھڪڙي جي بنياد تي ھڪڙي شاخ ٺاھيو

هڪ برانچ ٺاهڻ جو ٻيو طريقو ٻئي تي تعمير ڪرڻ آهي. مان ماسٽر برانچ جي بنياد تي هڪ برانچ ٺاهڻ چاهيان ٿو، تنهنڪري مون کي پهريان ان کي تبديل ڪرڻ جي ضرورت آهي، ۽ ايندڙ قدم هڪ نئين ٺاهڻ آهي. اچو ته ڏسون:

• git چيڪ آئوٽ ماسٽر - ماسٽر برانچ ڏانهن وڃو؛
• git اسٽيٽس - چيڪ ڪريو ته اهو ماسٽر تي آهي.

هتي توهان ڏسي سگهو ٿا ته اسان ماسٽر برانچ ڏانهن منتقل ڪيو ويو آهي، git ignore اڳ ۾ ئي هتي ڪم ڪري رهيو آهي، ۽ مرتب ڪيل ڪلاس هاڻي اڻڄاتل طور تي ظاهر نه ٿيندو. ھاڻي اسان ھڪڙي نئين شاخ ٺاھيون ٿا ماسٽر برانچ جي بنياد تي:

git checkout -b feature/update-txt-files

جيڪڏهن توهان کي ڪو شڪ آهي ته هي برانچ ماسٽر وانگر نه هوندي، توهان آساني سان هن کي چيڪ ڪري سگهو ٿا git log لکڻ ۽ سڀني ڪمن کي ڏسي. انهن مان چار هجڻ گهرجي.

تڪرار حل ڪريو

ان کان اڳ جو اسان سمجھون تڪرار ڇا آھي، اسان کي ھڪڙي شاخ کي ٻي شاخ ۾ ضم ڪرڻ (ضم ڪرڻ) بابت ڳالهائڻ جي ضرورت آھي. ھي تصوير ان عمل کي ڏيکاري سگھي ٿي جڏھن ھڪڙي شاخ ٻيءَ ۾ ضم ٿي وڃي: اھو آھي، ھڪڙي مکيه شاخ آھي. ڪجهه نقطي تي، هڪ ثانوي ان مان ٺاهيو ويندو آهي، جنهن ۾ تبديليون ٿينديون آهن. هڪ دفعو ڪم ڪيو ويندو، توهان کي هڪ شاخ کي ٻئي ۾ ضم ڪرڻ جي ضرورت آهي. مان مختلف خصوصيتن کي بيان نه ڪندس: مان صرف هن مضمون جي فريم ورڪ ۾ سمجھڻ چاهيان ٿو، ۽ جيڪڏهن ضروري هجي ته توهان تفصيل پاڻ ڳوليندا. تنهن ڪري، اسان جي مثال ۾، اسان خصوصيت/update-txt-files برانچ ٺاهي. جيئن برانچ جي نالي ۾ لکيل آهي، اسان متن کي اپڊيٽ ڪنداسين. ھاڻي توھان کي ضرورت آھي ھن معاملي لاءِ ھڪڙو نئون عزم ٺاھيو:

git add *.txt 
git commit -m “updated txt files”
git log

هاڻي، جيڪڏهن اسان کي ضم ڪرڻ چاهيون ٿا مضمون/update-txt-files برانچ ماسٽر ۾، اسان کي ماسٽر ڏانهن وڃڻ گهرجي ۽ لکڻ جي ضرورت آهي git merge feature/update-txt-files:

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

نتيجي طور، ھاڻي ماسٽر برانچ پڻ ھڪڙو عزم آھي جيڪو شامل ڪيو ويو خصوصيت/update-txt-files ۾. هي ڪارڪردگي شامل ڪئي وئي آهي تنهنڪري توهان خصوصيت شاخ کي حذف ڪري سگهو ٿا. ائين ڪرڻ لاءِ اسين لکون ٿا:

git branch -D feature/update-txt-files

ايترو پري اهو واضح آهي، صحيح؟ اچو ته صورتحال کي پيچيده ڪريو: ھاڻي چئو ته اسان کي txt فائل کي تبديل ڪرڻ جي ضرورت آھي. پر هاڻي هي فائل به وزرڊ ۾ تبديل ٿي ويندي. اھو آھي، اھو متوازي ۾ تبديل ٿيندو، ۽ گٽ سمجھڻ جي قابل نه ھوندو ته ھڪڙي صورتحال ۾ ڇا ڪرڻ جي ضرورت آھي جڏھن اسان نئين ڪوڊ کي ماسٽر برانچ ۾ ضم ڪرڻ چاھيو ٿا. وڃ! اسان ماسٽر جي بنياد تي هڪ نئين برانچ ٺاهي، text_resource.txt ۾ تبديليون آڻيون ۽ هن معاملي لاء هڪ عزم ٺاهيو:

git checkout -b feature/add-header
... делаем изменения в файле

git add *.txt
git commit -m “added header to txt”

ماسٽر برانچ ڏانھن وڃو ۽ ھن ٽيڪسٽ فائل کي ساڳئي لائن تي اپڊيٽ ڪريو جيئن فيچر برانچ:

git checkout master
… обновor test_resource.txt

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

۽ ھاڻي سڀ کان وڌيڪ دلچسپ لمحو: توھان کي تبديل ڪرڻ جي ضرورت آھي فيچر/add-header برانچ مان ماسٽر ڏانھن. اسان ماسٽر برانچ تي آهيون، تنهنڪري اسان کي صرف لکڻ جي ضرورت آهي:

git merge feature/add-header

پر اسان نتيجو حاصل ڪنداسين test_resource.txt فائل ۾ تڪرار سان: ۽ هتي اسان ڏسي سگهون ٿا ته Git آزاديء سان فيصلو نه ڪري سگهيو ته هن ڪوڊ کي ڪيئن ملائي ۽ چوي ٿو ته اسان کي پهريان تڪرار کي حل ڪرڻ گهرجي، ۽ صرف پوء هڪ عزم ٺاهيو. ٺيڪ، اچو ته فائل کي کوليون جنهن ۾ تضاد موجود آهي ٽيڪسٽ ايڊيٽر ۾ ۽ ڏسو: سمجھڻ لاءِ ته گٽ هتي ڇا ڪيو، توهان کي ياد رکڻ گهرجي ته اسان ڇا لکيو آهي ڪٿي ۽ موازنہ:

1. "<<<<<<< HEAD" ۽ "=======" جي وچ ۾ اهي ماسٽر تبديليون آهن جيڪي ماسٽر برانچ ۾ هن لائن ۾ هيون.
2. "=======" ۽ ">>>>>>> فيچر/add-header" جي وچ ۾ اهي تبديليون آهن جيڪي فيچر/add-header برانچ ۾ هيون.

اهڙيء طرح، گٽ ڏيکاري ٿو ته هن نقطي تي هو اهو نه سمجهي سگهيو ته هن فائل کي ڪيئن ملائي، هن حصي کي مختلف شاخن مان ٻن حصن ۾ ورهايو ۽ تجويز ڪيو ته اسان پاڻ لاء فيصلو ڪيو. ٺيڪ آهي، هڪ مضبوط ارادي سان آئون هر شيء کي هٽائڻ جو فيصلو ڪريان ٿو، صرف لفظ هيڊر ڇڏي ڏيو: اچو ته تبديلين جي صورتحال تي نظر رکون، وضاحت ٿورو مختلف ٿيندو. ڪابه تبديل ٿيل رياست نه هوندي، پر غير ضم ٿيل. تنهنڪري اسان محفوظ طور تي پنجين رياست شامل ڪري سگهون ٿا ... پر مان سمجهان ٿو ته اهو غير ضروري آهي، اچو ته ڏسو:

git status

اسان کي يقين هو ته هي هڪ مختلف، غير معمولي ڪيس هو. اچو ته جاري رکون:

git add *.txt

تفصيل ۾ توهان نوٽيس ڪندا ته اهي صرف گٽ ڪمٽ لکڻ جي صلاح ڏين ٿا. اسان ٻڌون ٿا ۽ لکون ٿا:

git commit

۽ اهو سڀ ڪجهه آهي: هي آهي اسان اهو ڪيئن ڪيو - اسان ڪنسول ۾ تڪرار حل ڪيو. يقينن، ترقي جي ماحول ۾ توهان اهو ٿورو آسان ڪري سگهو ٿا، مثال طور، Intellij IDEA ۾ هر شي کي ايترو سٺو ترتيب ڏنو ويو آهي ته توهان ان ۾ سڀ ضروري ڪم ڪري سگهو ٿا. پر ترقيءَ جو ماحول تمام گهڻو ڪم ڪري ٿو، ۽ اسان اڪثر نٿا سمجهون ته اتي ڇا ٿيو آهي. ۽ جڏهن سمجهه ۾ نه اچي ته پوءِ مسئلا پيدا ٿي سگهن ٿا.

ريموٽ ريپوزٽريز سان ڪم ڪرڻ

آخري قدم ڪجھ وڌيڪ حڪمن کي سمجھڻ آھي جيڪي ريموٽ مخزن سان ڪم ڪرڻ جي ضرورت آھي. جيئن ته مون اڳ ۾ ئي چيو آهي، هڪ ريموٽ مخزن ڪجهه هنڌ آهي جتي مخزن کي محفوظ ڪيو ويندو آهي ۽ جتان توهان ان کي ڪلون ڪري سگهو ٿا. ريموٽ ريپوزٽريز جا ڪهڙا قسم آهن؟ اهڙا ڪيترائي مثال آهن:

• GitHub ذخيرو ۽ تعاون جي ترقي لاء سڀ کان وڏو مخزن آهي. مون اڳئين مضمونن ۾ اڳ ۾ ئي بيان ڪيو آهي. منهنجي Github اڪائونٽ
  ۾ رڪنيت حاصل ڪريو . آئون اڪثر اتي پنهنجي ڪم جي نمائش ڪندو آهيان انهن علائقن ۾ جيڪي آئون پنهنجي ڪم دوران پڙهندو آهيان.

• GitLab هڪ اوپن سورس ويب تي ٻڌل DevOps لائف سائڪ ٽول آهي جيڪو مهيا ڪري ٿو ڪوڊ ريپوزٽري مئنيجمينٽ سسٽم Git لاءِ ان جي پنهنجي وڪي، ايشو ٽريڪنگ سسٽم ، CI/CD پائپ لائن ۽ ٻيون خاصيتون. خبرن کان پوء Microsoft خريد ڪيو GitHub، ڪجهه ڊولپرز انهن جي ڪم کي نقل ڪيو GitLab ۾.
  

• BitBucket هڪ ويب سروس آهي ميزباني منصوبن ۽ انهن جي گڏيل ترقي لاءِ، مرڪيوريل ۽ گيٽ ورزن ڪنٽرول سسٽم تي ٻڌل آهي. هڪ دفعي ان کي GitHub تي وڏو فائدو حاصل هو ته ان ۾ مفت نجي ذخيرا هئا. گذريل سال، GitHub پڻ هن خصوصيت کي هر ڪنهن لاء مفت ۾ دستياب ڪيو.

• ۽ ايئن…

پهرين شيء جيڪا توهان کي ڪرڻ جي ضرورت آهي جڏهن ريموٽ مخزن سان ڪم ڪري رهيو آهي پروجيڪٽ کي توهان جي مقامي ۾ ڪلون ڪرڻ. هن معاملي لاء، مون پروجيڪٽ کي برآمد ڪيو جيڪو اسان مقامي طور تي ٺاهيو، ۽ هاڻي هرڪو ان کي پنهنجي لاء لکي سگهي ٿو:

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

هاڻي مقامي طور تي منصوبي جي مڪمل ڪاپي آهي. پڪ ڪرڻ لاء ته منصوبي جي تازي ڪاپي مقامي طور تي واقع آهي، توهان کي ضرورت آهي، جيئن اهي چون ٿا، ڊيٽا کي ڊمپ ڪندي لکڻ:

git pull

اسان جي حالت ۾، هاڻي ڪجھ به نه بدلجي ويو آهي، تنهن ڪري جواب آهي: اڳ ۾ ئي تاريخ تائين. پر جيڪڏهن مان ريموٽ ريپوزٽري ۾ ڪجهه تبديليون ڪريان، ته مقامي اپڊيٽ ٿي ويندي جڏهن اسان انهن کي ڇڪينداسين. ۽ نيٺ، آخري حڪم ڊيٽا کي ريموٽ مخزن ڏانهن ڌڪڻ آهي. جڏهن اسان مقامي طور تي ڪجهه ڪيو آهي ۽ ان کي ريموٽ مخزن ڏانهن منتقل ڪرڻ چاهيون ٿا، اسان کي پهريون ڀيرو مقامي طور تي هڪ نئون عزم ٺاهڻ گهرجي. هن کي ڪرڻ لاء، اچو ته اسان جي ٽيڪسٽ فائل ۾ ٻيو ڪجهه شامل ڪريو: هاڻي اهو اسان لاء هڪ عام شيء آهي - اسان هن معاملي لاء هڪ عزم ٺاهيندا آهيون:

git add test_resource.txt
git commit -m “prepated txt for pushing”

۽ ھاڻي ھن کي ريموٽ مخزن ڏانھن ڌڪڻ جو حڪم:

git push

اهو سڀ ڪجهه مان توهان کي ٻڌائڻ چاهيان ٿو. توهان جي توجه لاء مهرباني. رڪنيت حاصل ڪريو منهنجي GitHub اڪائونٽ ، جتي آئون پوسٽ ڪريان ٿو مختلف سٺا مثال پروجيڪٽ مان جيڪي آئون پڙهان ٿو ۽ ڪم تي استعمال ڪريان ٿو.

مفيد لنڪس

• Git تي سرڪاري دستاويز روسي ۾ آهي . مان ان کي سفارش ڪريان ٿو ريفرنس گائيڊ طور.
• گيت