การแข่งขันที่เกิดขึ้นในสวรรค์: Git และ IntelliJ IDEA

ตามธรรมเนียมปฏิบัติ ฉันขอต้อนรับคุณในฐานะวิศวกรซอฟต์แวร์อาวุโสในอนาคต บทความวัน นี้เป็นส่วนขยายเชิงตรรกะของบทความของฉันเกี่ยวกับ Git ในบทความเกี่ยวกับ Git ฉันได้อธิบายวิธีการทำงานกับ Git บนบรรทัดคำสั่ง วันนี้ฉันจะแสดงวิธีทำทั้งหมดใน IntelliJ IDEA ในช่วงเริ่มต้นของการเดินทางในฐานะนักพัฒนา ฉันใช้บรรทัดคำสั่งและคิดว่าฉันไม่จำเป็นต้องมี GUI สำหรับสิ่งนี้ ท้ายที่สุด ทุกอย่างก็ชัดเจนเหมือนเดิม... แต่นั่นมันก็มาถึงตอนที่ฉันเริ่มใช้ Git ใน IntelliJ IDEA... ตั้งแต่เริ่มแรก ฉันอยากจะบอกว่าฉันกำลังอธิบายประสบการณ์ส่วนตัวของฉัน มีหลายวิธีในการแก้ปัญหาที่กำหนดใน IntelliJ IDEA หากคุณรู้วิธีที่ดีกว่าที่ฉันจะอธิบายในบทความ เขียนไว้ในความคิดเห็นแล้วเราจะคุยกัน

อินพุตที่จำเป็น:

1. อ่าน ทำตาม และทำความเข้าใจบทความของฉันเกี่ยวกับ Git สิ่งนี้จะช่วยให้แน่ใจว่าทุกอย่างถูกตั้งค่าและพร้อมใช้งาน
2. ติดตั้ง IntelliJ IDEA
3. จัดสรรเวลาส่วนตัวหนึ่งชั่วโมงเพื่อให้ได้ความเชี่ยวชาญอย่างสมบูรณ์

มาทำงานกับโครงการสาธิตที่ฉันใช้สำหรับบทความเกี่ยวกับ Git อัปเดต:ในขณะที่เผยแพร่ GitHub UI ใหม่จะพร้อมใช้งาน และบางไอคอนจะไม่แสดงในบทความ อย่าตื่นตระหนก คุณเพียงแค่ต้องไม่เปลี่ยนไปใช้ UI ใหม่หรือมองหาสิ่งเหล่านั้น

โคลนโครงการในเครื่อง

มีสองตัวเลือกที่นี่:

1. หากคุณมีบัญชี GitHub อยู่แล้วและต้องการผลักดันบางอย่างในภายหลัง จะเป็นการดีกว่าที่จะแยกโครงการและคัดลอกสำเนาของคุณเอง
2. โคลนพื้นที่เก็บข้อมูลของฉันและทำทุกอย่างในเครื่องโดยไม่ต้องส่งสิ่งทั้งหมดไปยังเซิร์ฟเวอร์ ท้ายที่สุดนี่คือที่เก็บของฉัน :)

ในการโคลนโครงการจาก GitHub คุณต้องคัดลอกลิงก์โครงการและส่งต่อไปยัง IntelliJ IDEA:

1. คัดลอกที่อยู่โครงการ:

2. เปิด IntelliJ IDEA แล้วเลือก "รับจากการควบคุมเวอร์ชัน":

3. คัดลอกและวางที่อยู่โครงการ:

4. คุณจะได้รับแจ้งให้สร้างโครงการ IntelliJ IDEA ยอมรับข้อเสนอ:

5. เนื่องจากไม่มีระบบการสร้างและอยู่นอกเหนือขอบเขตของบทความนี้ เราจึงเลือกสร้างโครงการจากแหล่งข้อมูลที่มีอยู่ :

6. ถัดไป คุณจะเห็นหน้าจอที่สวยงามนี้: ตอนนี้เราเข้าใจเรื่องการโคลนนิ่งแล้ว คุณสามารถดูไปรอบๆ

ดูครั้งแรกที่ IntelliJ IDEA ในฐานะ Git UI

ลองดูโปรเจ็กต์โคลนให้ละเอียดยิ่งขึ้น: คุณสามารถรับข้อมูลมากมายเกี่ยวกับระบบควบคุมเวอร์ชันได้แล้ว ขั้นแรก เรามี บานหน้าต่าง การควบคุมเวอร์ชันที่มุมล่างซ้าย ที่นี่คุณสามารถค้นหาการเปลี่ยนแปลงในเครื่องทั้งหมดและรับรายการคอมมิชชัน (คล้ายกับ "git log") ไปที่การสนทนาของLogกันเถอะ มีการสร้างภาพข้อมูลบางอย่างที่ช่วยให้เราเข้าใจว่าการพัฒนาดำเนินไปอย่างไร ตัวอย่างเช่น คุณจะเห็นว่ามีการสร้างสาขาใหม่โดยเพิ่มส่วนหัวลงใน txt commit ซึ่งต่อมาจะรวมเข้ากับสาขาหลัก หากคุณคลิกที่คอมมิต คุณจะเห็นข้อมูลทั้งหมดเกี่ยวกับการคอมมิตที่มุมขวา: การเปลี่ยนแปลงและข้อมูลเมตาทั้งหมดนอกจากนี้ยังสามารถเห็นการเปลี่ยนแปลงที่เกิดขึ้นจริง เรายังเห็นว่าความขัดแย้งได้รับการแก้ไขที่นั่น IDEA ก็นำเสนอเรื่องนี้ได้เป็นอย่างดี หากคุณดับเบิลคลิกที่ไฟล์ที่มีการเปลี่ยนแปลงระหว่างการคอมมิตนี้ เราจะดูว่าข้อขัดแย้งได้รับการแก้ไขอย่างไร: โปรดทราบว่าทางด้านซ้ายและด้านขวาเรามีไฟล์เดียวกันสองเวอร์ชันซึ่งจำเป็นต้องรวมเป็นไฟล์เดียว และตรงกลาง เราได้ผลการรวมสุดท้าย เมื่อโครงการมีสาขา คอมมิชชัน และผู้ใช้จำนวนมาก คุณต้องค้นหาแยกกันตามสาขา ผู้ใช้ และวันที่: สิ่งสุดท้ายที่ฉันต้องการอธิบายก่อนที่เราจะเริ่มต้นคือวิธีทำความเข้าใจว่าเราอยู่ในสาขาใด ฉันจะให้คุณ นาทีที่จะคิดออก ... คุณพบหรือไม่? ยอมแพ้? :D ที่มุมล่างขวา มีปุ่มชื่อGit: master. สิ่งที่ตามมา "Git:" คือสาขาปัจจุบัน หากคุณคลิกปุ่ม คุณจะสามารถทำสิ่งที่มีประโยชน์ได้มากมาย: เปลี่ยนไปใช้สาขาอื่น สร้างสาขาใหม่ เปลี่ยนชื่อสาขาที่มีอยู่ และอื่นๆ

การทำงานกับที่เก็บข้อมูล

ปุ่มลัดที่มีประโยชน์

สำหรับงานในอนาคต คุณต้องจำปุ่มลัดที่มีประโยชน์มากสองสามตัว:

0. CTRL+T — รับการเปลี่ยนแปลงล่าสุดจากที่เก็บระยะไกล (git pull)
1. CTRL+K — สร้างคอมมิชชัน / ดูการเปลี่ยนแปลงปัจจุบันทั้งหมด ซึ่งรวมถึงไฟล์ที่ไม่ได้ติดตามและแก้ไข (ดูบทความของฉันเกี่ยวกับคอมไพล์ ซึ่งอธิบายเรื่องนี้) (คอมไพล์คอมไพล์)
2. CTRL+SHIFT+K — นี่คือคำสั่งสำหรับการพุชการเปลี่ยนแปลงไปยังที่เก็บระยะไกล คอมมิชชันทั้งหมดที่สร้างขึ้นในเครื่องและยังไม่ได้อยู่ในที่เก็บระยะไกลจะถูกพุช (git push)
3. ALT+CTRL+Z — ย้อนกลับการเปลี่ยนแปลงในไฟล์ที่ระบุเป็นสถานะของการกระทำล่าสุดที่สร้างขึ้นในพื้นที่เก็บข้อมูลในเครื่อง หากคุณเลือกทั้งโครงการที่มุมซ้ายบน คุณสามารถย้อนกลับการเปลี่ยนแปลงในไฟล์ทั้งหมดได้

เราต้องการอะไร

เพื่อให้งานสำเร็จ เราจำเป็นต้องเชี่ยวชาญสถานการณ์พื้นฐานที่ใช้ทุกที่ วัตถุประสงค์คือเพื่อใช้งานฟังก์ชันใหม่ในสาขาที่แยกจากกัน จากนั้นส่งไปยังที่เก็บระยะไกล (จากนั้นคุณต้องสร้างคำขอดึงไปยังสาขาหลักด้วย แต่นั่นอยู่นอกเหนือขอบเขตของบทความนี้) สิ่งที่จำเป็นในการทำเช่นนี้?

1. รับการเปลี่ยนแปลงปัจจุบันทั้งหมดในสาขาหลัก (เช่น "ต้นแบบ")

2. จากสาขาหลักนี้ ให้สร้างสาขาแยกต่างหากสำหรับงานของคุณ

3. ใช้ฟังก์ชันใหม่

4. ไปที่สาขาหลักและตรวจสอบว่ามีการเปลี่ยนแปลงใหม่ในขณะที่เรากำลังดำเนินการอยู่หรือไม่ ถ้าไม่เช่นนั้นทุกอย่างก็เรียบร้อยดี แต่ถ้ามีการเปลี่ยนแปลงเราจะทำสิ่งต่อไปนี้: ไปที่สาขาที่ทำงานและรีบูตการเปลี่ยนแปลงจากสาขาหลักเป็นของเรา ถ้าทุกอย่างเป็นไปด้วยดีก็ดี แต่เป็นไปได้ทั้งหมดที่จะมีความขัดแย้ง เมื่อเกิดขึ้นแล้ว พวกเขาสามารถแก้ไขได้ล่วงหน้า โดยไม่ต้องเสียเวลาในที่เก็บระยะไกล

   คุณสงสัยหรือไม่ว่าทำไมคุณต้องทำสิ่งนี้? เป็นมารยาทที่ดีและป้องกันไม่ให้ความขัดแย้งเกิดขึ้นหลังจากส่งสาขาของคุณไปยังที่เก็บในเครื่อง (แน่นอนว่ามีความเป็นไปได้ที่ความขัดแย้งจะยังคงเกิดขึ้น แต่มันจะเล็กลงมาก )

5. พุชการเปลี่ยนแปลงของคุณไปยังที่เก็บระยะไกล

อะไรจะเกิดขึ้นต่อไปขึ้นอยู่กับงานและจินตนาการของคุณ

รับการเปลี่ยนแปลงจากเซิร์ฟเวอร์ระยะไกลหรือไม่

ฉันเพิ่มคำอธิบายใน README ด้วยคอมมิตใหม่และต้องการรับการเปลี่ยนแปลงเหล่านี้ หากมีการเปลี่ยนแปลงทั้งในที่เก็บข้อมูลในเครื่องและในรีโมต เราได้รับเชิญให้เลือกระหว่างการรวมและการรีเบส เราเลือกที่จะผสาน ป้อน CTRL+T : ตอนนี้คุณสามารถดูว่า README มีการเปลี่ยนแปลงอย่างไร เช่น การเปลี่ยนแปลงจากที่เก็บระยะไกลถูกดึงเข้ามา และที่มุมล่างขวา คุณสามารถดูรายละเอียดทั้งหมดของการเปลี่ยนแปลงที่มาจากเซิร์ฟเวอร์

สร้างสาขาใหม่ตามต้นแบบ

ทุกอย่างเรียบง่ายที่นี่

1. ไปที่มุมล่างขวาแล้วคลิกGit: master เลือก+ สาขาใหม่

ปล่อยให้ ช่องทำเครื่องหมาย Checkout สาขาที่เลือกไว้และป้อนชื่อสาขาใหม่ สำหรับฉัน แล้วมันจะเป็นreadme-improver

Git: masterจะเปลี่ยนเป็น Git : readme-improver

มาจำลองการทำงานแบบคู่ขนานกัน

เพื่อให้ความขัดแย้งปรากฏขึ้น ต้องมีคนสร้างมันขึ้นมา :D ผมจะแก้ไข README ด้วยการคอมมิตใหม่ผ่านเบราว์เซอร์ ซึ่งจะเป็นการจำลองการทำงานแบบคู่ขนานกัน ราวกับว่ามีคนทำการเปลี่ยนแปลงในไฟล์เดียวกันขณะที่ฉันกำลังแก้ไขอยู่ ผลที่ตามมาคือความขัดแย้ง ฉันจะลบคำว่า "fully" ออกจากบรรทัดที่ 10

ใช้ฟังก์ชันของเรา

งานของเราคือเปลี่ยน README และเพิ่มคำอธิบายให้กับบทความใหม่ นั่นคืองานใน Git ต้องผ่าน IntelliJ IDEA เพิ่มสิ่งนี้: การเปลี่ยนแปลงเสร็จสิ้น ตอนนี้เราสามารถสร้างคอมมิชชันได้แล้ว กดCTRL+Kซึ่งจะช่วยให้เรา: ก่อนที่จะสร้างการคอมมิต เราจำเป็นต้องพิจารณาอย่างใกล้ชิดว่าหน้าต่างนี้นำเสนออะไร ฉันเพิ่มลูกศรสีแดงเพื่อแสดงตำแหน่งที่ต้องมอง ที่นี่มีสิ่งที่น่าสนใจมากมาย ใน ส่วน Commit Messageเราเขียนข้อความที่เกี่ยวข้องกับ Commit จากนั้นในการสร้างเราต้องคลิกตกลง. ฉันยังไม่พบวิธีการทำเช่นนี้ด้วยปุ่มลัด หากมีใครรู้วิธี โปรดเขียนถึงฉัน — นั่นจะทำให้ฉันมีความสุขมาก เราเขียนว่า README มีการเปลี่ยนแปลงและสร้างการคอมมิต การแจ้งเตือนปรากฏขึ้นที่มุมซ้ายล่างพร้อมชื่อของการคอมมิต:

ตรวจสอบว่าสาขาหลักมีการเปลี่ยนแปลงหรือไม่

เราเสร็จสิ้นภารกิจของเรา มันได้ผล. เราเขียนการทดสอบ ทุกอย่างปกติดี. แต่ก่อนที่จะส่งไปยังเซิร์ฟเวอร์ เรายังคงต้องตรวจสอบว่ามีการเปลี่ยนแปลงใด ๆ ในสาขาหลักในระหว่างนี้หรือไม่ มันเกิดขึ้นได้อย่างไร? ค่อนข้างง่าย: มีคนรับงานต่อจากคุณ และมีคนทำงานนั้นเสร็จเร็วกว่าคุณทำงานให้เสร็จ ดังนั้นเราต้องไปที่สาขาหลัก ในการทำเช่นนี้ เราต้องทำตามที่แสดงในมุมล่างขวาของภาพหน้าจอด้านล่าง: ในสาขาหลัก ให้กดCTRL+Tเพื่อรับการเปลี่ยนแปลงล่าสุดจากเซิร์ฟเวอร์ระยะไกล เมื่อพิจารณาถึงการเปลี่ยนแปลง คุณจะเห็นสิ่งที่เกิดขึ้นได้อย่างง่ายดาย:คำว่า "fully" ถูกลบออก อาจมีบางคนจากฝ่ายการตลาดตัดสินใจว่าไม่ควรเขียนแบบนั้นและให้งานแก่นักพัฒนาในการอัปเดต ขณะนี้เรามีสำเนาของมาสเตอร์แบรนช์เวอร์ชันล่าสุดในเครื่องแล้ว กลับไปreadme-ปรับปรุง ตอนนี้เราต้องรีเบสการเปลี่ยนแปลงจากสาขาหลักเป็นของเรา เราทำสิ่งนี้: หากคุณทำทุกอย่างถูกต้องและทำตามฉัน ผลลัพธ์ควรแสดงความขัดแย้งในไฟล์ README: ที่นี่ เรายังมีข้อมูลมากมายให้ทำความเข้าใจและดื่มด่ำ นี่คือรายการไฟล์ (ในกรณีของเราคือไฟล์เดียว) ที่มีข้อขัดแย้ง เราสามารถเลือกได้สามตัวเลือกคือ

1. ยอมรับของคุณ — ยอมรับเฉพาะการเปลี่ยนแปลงจาก readme-improver
2. ยอมรับของพวกเขา — ยอมรับการเปลี่ยนแปลงจากเจ้านายเท่านั้น
3. รวม — เลือกด้วยตัวคุณเองว่าคุณต้องการเก็บอะไรและทิ้งอะไร

ยังไม่ชัดเจนว่ามีการเปลี่ยนแปลงอะไร หากมีการเปลี่ยนแปลงเป็นสาขาหลัก จำเป็นต้องมีการเปลี่ยนแปลงที่นั่น ดังนั้นเราจึงไม่สามารถยอมรับการเปลี่ยนแปลงของเราได้ ดังนั้น เราเลือกผสาน : ที่นี่เราจะเห็นว่ามีสามส่วน:

1. นี่คือการเปลี่ยนแปลงจากโปรแกรมปรับปรุง readme
2. ผลลัพธ์ที่ผสาน สำหรับตอนนี้ สิ่งที่มีอยู่ก่อนการเปลี่ยนแปลง
3. การเปลี่ยนแปลงจากสาขาหลัก

เราจำเป็นต้องสร้างผลลัพธ์ที่ผสานกันซึ่งจะทำให้ทุกคนพึงพอใจ ตรวจสอบสิ่งที่เปลี่ยนแปลงก่อนการเปลี่ยนแปลงของเรา เราพบว่าพวกเขาเพียงแค่ลบคำว่า "fully" ได้ไม่มีปัญหา! นั่นหมายความว่าเราจะลบออกในผลลัพธ์ที่ผสานแล้วเพิ่มการเปลี่ยนแปลงของเรา เมื่อเราแก้ไขผลลัพธ์ที่ผสานแล้ว เราสามารถคลิกใช้ จากนั้นการแจ้งเตือนจะปรากฏขึ้นเพื่อบอกเราว่าการรีบูตสำเร็จแล้ว: ที่นั่น! เราแก้ไขข้อขัดแย้งแรกของเราผ่าน IntelliJ IDEA :D

ผลักดันการเปลี่ยนแปลงไปยังเซิร์ฟเวอร์ระยะไกล

ขั้นตอนต่อไปคือการผลักดันการเปลี่ยนแปลงไปยังเซิร์ฟเวอร์ระยะไกลและสร้างคำขอดึง ในการทำเช่นนี้ เพียงกดCTRL+SHIFT+ K จากนั้นเราจะได้รับ: ทางด้านซ้ายจะมีรายการคอมมิชชันที่ยังไม่ได้ส่งไปยังที่เก็บระยะไกล ทางด้านขวาจะเป็นไฟล์ทั้งหมดที่มีการเปลี่ยนแปลง และนั่นแหล่ะ! กดPushแล้วคุณจะพบกับความสุข :) หาก Push สำเร็จ คุณจะเห็นการแจ้งเตือนแบบนี้ที่มุมขวาล่าง:

ส่วนโบนัส

ในตอนแรกฉันไม่ต้องการเพิ่มการสร้างคำขอดึงข้อมูลในบทความนี้ แต่มันจะไม่สมบูรณ์หากไม่มีสิ่งนี้ ไปที่ที่เก็บ GitHub กัน เถอะ(แน่นอนว่าเป็นของคุณ :)) และเราเห็นว่า GitHub รู้แล้วว่าเราต้องการอะไร: คลิกเปรียบเทียบ & ดึงคำขอ จากนั้นคลิกสร้างคำขอดึงข้อมูล เนื่องจากเราแก้ไขข้อขัดแย้งล่วงหน้า ตอนนี้เมื่อสร้างคำขอดึงข้อมูล เราสามารถผสานได้ทันที: และนั่นคือทั้งหมดที่ฉันอยากจะพูดในครั้งนี้ แน่นอน ฉันได้เปิดประตูให้คุณเพียงเล็กน้อยและแสดงให้คุณเห็นส่วนเล็กๆ คุณจะได้เรียนรู้เกี่ยวกับส่วนที่เหลือตามที่คุณต้องการ ฉันมีนิสัยชอบเชิญชวนให้คุณติดตามฉันบน GitHubที่ฉันโพสต์โครงการของฉันเกี่ยวกับเทคโนโลยีต่างๆ ที่ฉันใช้ในที่ทำงาน ฉันเพิ่งสร้างความสำเร็จส่วนตัวโครงการหนึ่งของฉันได้รับดาวจากนักพัฒนามากกว่าร้อยคน มีความรู้สึกดีใจอย่างเหลือเชื่อเมื่อคุณรู้ว่าสิ่งที่คุณทำกำลังถูกใช้โดยคนอื่น และใช้มันให้เกิดประโยชน์

ลิงค์ที่มีประโยชน์

1. CodeGym: เริ่มต้นใช้งาน Git: คู่มือฉบับสมบูรณ์สำหรับมือใหม่
2. GitHub: โครงการสาธิตสำหรับฝึกฝน
3. JetBrains: ตั้งค่าที่เก็บ Git
4. GitHub: บัญชีของฉัน