เริ่มต้นใช้งาน Git: คู่มือฉบับสมบูรณ์สำหรับมือใหม่

แทนที่จะเป็นการแนะนำตัว

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

พื้นฐาน Git

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

การติดตั้ง Git

มาติดตั้ง Java บนคอมพิวเตอร์ของคุณกันเถอะ

การติดตั้งบน Windows

ตามปกติ คุณต้องดาวน์โหลดและเรียกใช้ไฟล์ exe ทุกอย่างง่ายที่นี่: คลิกที่ลิงค์แรกของ Googleทำการติดตั้ง เท่านี้ก็เรียบร้อย ในการทำเช่นนี้ เราจะใช้ bash Console ที่ Windows จัดเตรียมไว้ให้ ใน Windows คุณต้องเรียกใช้ Git Bash นี่คือลักษณะที่ปรากฏในเมนูเริ่ม: นี่คือพรอมต์คำสั่งที่คุณสามารถใช้งานได้ เพื่อหลีกเลี่ยงการต้องไปที่โฟลเดอร์ที่มีโปรเจ็กต์ทุกครั้งเพื่อเปิด Git ที่นั่น คุณสามารถเปิดพรอมต์คำสั่งในโฟลเดอร์โปรเจ็กต์ด้วยปุ่มเมาส์ขวาพร้อมพาธที่เราต้องการ:

การติดตั้งบน Linux

โดยปกติแล้ว Git จะเป็นส่วนหนึ่งของลีนุกซ์ดิสทริบิวชันและติดตั้งไว้แล้ว เนื่องจากมันเป็นเครื่องมือที่เดิมเขียนขึ้นสำหรับการพัฒนาเคอร์เนลของลินุกซ์ แต่มีบางสถานการณ์ที่ไม่เป็นเช่นนั้น ในการตรวจสอบ คุณต้องเปิดเทอร์มินัลแล้วเขียน: git --version หากคุณได้รับคำตอบที่เข้าใจได้ ก็ไม่จำเป็นต้องติดตั้งอะไร เปิดเทอร์มิ นัลและติดตั้ง Git บน Ubuntu ฉันกำลังทำงานกับ Ubuntu ดังนั้นฉันสามารถบอกคุณได้ว่าจะเขียนอะไร: sudo apt-get install git

การติดตั้งบน macOS

ก่อนอื่นคุณต้องตรวจสอบว่ามี Git อยู่แล้วหรือไม่ หากคุณยังไม่มี วิธีที่ง่ายที่สุดในการดาวน์โหลดคือ ดาวน์โหลดเวอร์ชันล่าสุดที่นี่ . หากติดตั้ง Xcode แล้ว Git จะถูกติดตั้งโดยอัตโนมัติอย่างแน่นอน

การตั้งค่าคอมไพล์

Git มีการตั้งค่าผู้ใช้สำหรับผู้ใช้ที่จะส่งงาน สิ่งนี้สมเหตุสมผลและจำเป็น เนื่องจาก Git นำข้อมูลนี้ไปใช้ในฟิลด์ Author เมื่อมีการสร้างคอมมิต ตั้งค่าชื่อผู้ใช้และรหัสผ่านสำหรับโครงการทั้งหมดของคุณโดยเรียกใช้คำสั่งต่อไปนี้:

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

ทฤษฎีเล็กน้อย ...

เพื่อเจาะลึกหัวข้อนี้ เราควรแนะนำคุณเกี่ยวกับคำศัพท์และการกระทำใหม่ๆ...

• ที่เก็บคอมไพล์
• ให้สัญญา
• สาขา
• ผสาน
• ความขัดแย้ง
• ดึง
• ดัน
• วิธีละเว้นบางไฟล์ (.gitignore)

และอื่น ๆ

สถานะใน Git

Git มีรูปปั้นหลายอย่างที่ต้องเข้าใจและจดจำ:

• ไม่ได้ติดตาม
• แก้ไข
• จัดฉาก
• มุ่งมั่น

คุณควรเข้าใจเรื่องนี้อย่างไร?

นี่คือสถานะที่ใช้กับไฟล์ที่มีรหัสของเรา:

1. ไฟล์ที่สร้างขึ้นแต่ยังไม่ได้เพิ่มไปยังที่เก็บมีสถานะ "ไม่ถูกติดตาม"
2. เมื่อเราทำการเปลี่ยนแปลงไฟล์ที่เพิ่มไปยังที่เก็บ Git แล้ว สถานะของไฟล์จะเป็น "แก้ไข"
3. ในบรรดาไฟล์ที่เราเปลี่ยนแปลง เราเลือกไฟล์ที่เราต้องการ และคลาสเหล่านี้จะเปลี่ยนสถานะเป็น "staged"
4. การคอมมิตถูกสร้างขึ้นจากไฟล์ที่เตรียมไว้ในสถานะสเตจและไปที่ที่เก็บ Git หลังจากนั้น จะไม่มีไฟล์ที่มีสถานะ "จัดฉาก" แต่อาจมีไฟล์ที่มีสถานะ "แก้ไข"

นี่คือลักษณะ:

คอมมิตคืออะไร?

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

• ตัวระบุเฉพาะของคอมมิชชัน ซึ่งสามารถใช้ค้นหาได้
• ชื่อผู้เขียนคอมมิท ผู้สร้างมันขึ้นมา
• วันที่สร้างคอมมิท
• ความคิดเห็นที่อธิบายถึงสิ่งที่ทำระหว่างการกระทำ

นี่คือลักษณะ:

สาขาคืออะไร?

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

เริ่มต้นใช้งาน Git

คุณสามารถทำงานกับที่เก็บข้อมูลในเครื่องเพียงอย่างเดียวเช่นเดียวกับรีโมต ในการฝึกฝนคำสั่งที่จำเป็น คุณสามารถจำกัดตัวเองไว้ที่ที่เก็บในเครื่อง โดยจะเก็บข้อมูลทั้งหมดของโครงการไว้ในโฟลเดอร์ .git เท่านั้น หากเรากำลังพูดถึงพื้นที่เก็บข้อมูลระยะไกล ข้อมูลทั้งหมดจะถูกเก็บไว้ที่ใดที่หนึ่งบนเซิร์ฟเวอร์ระยะไกล: เฉพาะสำเนาของโครงการเท่านั้นที่จัดเก็บไว้ในเครื่อง การเปลี่ยนแปลงที่ทำกับสำเนาในเครื่องของคุณสามารถพุช (git push) ไปยังที่เก็บระยะไกลได้ ในการสนทนาของเราที่นี่และด้านล่าง เรากำลังพูดถึงการทำงานกับ Git ในคอนโซล แน่นอน คุณสามารถใช้โซลูชันที่ใช้ GUI บางประเภทได้ (เช่น IntelliJ IDEA) แต่ก่อนอื่น คุณควรทราบก่อนว่าคำสั่งใดถูกเรียกใช้งานและความหมายของคำสั่งเหล่านั้น

ทำงานกับ Git ในที่เก็บในเครื่อง

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

git init

สิ่งนี้จะสร้างโฟลเดอร์ .git ในไดเร็กทอรีปัจจุบันของคอนโซล โฟลเดอร์ .git เก็บข้อมูลทั้งหมดเกี่ยวกับที่เก็บ Git อย่าลบทิ้ง ;) ถัดไป ไฟล์จะถูกเพิ่มในโครงการ และกำหนดสถานะเป็น "Untracked" หากต้องการตรวจสอบสถานะปัจจุบันของงานของคุณ ให้เขียนสิ่งนี้:

git status

เราอยู่ในสาขาหลัก และเราจะอยู่ที่นี่จนกว่าเราจะเปลี่ยนไปใช้สาขาอื่น นี่แสดงว่าไฟล์ใดมีการเปลี่ยนแปลงแต่ยังไม่ได้เพิ่มในสถานะ "staged" หากต้องการเพิ่มลงในสถานะ "จัดฉาก" คุณต้องเขียน "git add" เรามีตัวเลือกบางอย่างที่นี่ เช่น:

• git add -A — เพิ่มไฟล์ทั้งหมดในสถานะ "staged"
• คอมไพล์เพิ่ม . — เพิ่มไฟล์ทั้งหมดจากโฟลเดอร์นี้และโฟลเดอร์ย่อยทั้งหมด โดยพื้นฐานแล้วสิ่งนี้เหมือนกับก่อนหน้านี้
• git add <ชื่อไฟล์> — เพิ่มไฟล์ที่ต้องการ ที่นี่คุณสามารถใช้นิพจน์ทั่วไปเพื่อเพิ่มไฟล์ตามรูปแบบบางอย่างได้ ตัวอย่างเช่น git add *.java: หมายความว่าคุณต้องการเพิ่มไฟล์ที่มีนามสกุล java เท่านั้น

สองตัวเลือกแรกนั้นง่ายอย่างชัดเจน สิ่งที่น่าสนใจยิ่งขึ้นด้วยการเพิ่มล่าสุด ดังนั้นมาเขียน:

git add *.txt

ในการตรวจสอบสถานะเราใช้คำสั่งที่เรารู้จักแล้ว:

git status

ที่นี่คุณจะเห็นว่านิพจน์ทั่วไปทำงานได้อย่างถูกต้อง: ขณะนี้ test_resource.txt มีสถานะเป็น "staged" และสุดท้าย ขั้นตอนสุดท้ายสำหรับการทำงานกับที่เก็บในเครื่อง (ยังมีอีกขั้นตอนหนึ่งเมื่อทำงานกับที่เก็บระยะไกล ;)) — การสร้างคอมมิชชันใหม่:

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 ในรูทของโปรเจ็กต์ แต่ละบรรทัดในไฟล์นี้แสดงถึงรูปแบบที่จะละเว้น ในตัวอย่างนี้ ไฟล์ .gitignore จะมีลักษณะดังนี้:

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

ลองดู:

• บรรทัดแรกคือการละเว้นไฟล์ทั้งหมดที่มีนามสกุล .class
• บรรทัดที่สองคือการละเว้นโฟลเดอร์ "เป้าหมาย" และทุกอย่างที่อยู่ในนั้น
• บรรทัดที่สามคือการละเว้นไฟล์ทั้งหมดที่มีนามสกุล .iml
• บรรทัดที่สี่คือการละเว้นโฟลเดอร์ .idea

ลองใช้ตัวอย่าง หากต้องการดูวิธีการทำงาน ให้เพิ่ม GitTest.class ที่คอมไพล์แล้วลงในโปรเจ็กต์และตรวจสอบสถานะโปรเจ็กต์:

git status

เห็นได้ชัดว่าเราไม่ต้องการเพิ่มคลาสที่คอมไพล์แล้วในโครงการโดยไม่ตั้งใจ (โดยใช้ git add -A) ในการทำเช่นนี้ ให้สร้างไฟล์ .gitignore และเพิ่มทุกอย่างที่อธิบายไว้ก่อนหน้านี้: ตอนนี้ ให้ใช้การคอมมิตเพื่อเพิ่มไฟล์ .gitignore ให้กับโปรเจ็กต์:

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

และตอนนี้เป็นช่วงเวลาแห่งความจริง: เรามีคลาส GitTest.class ที่คอมไพล์แล้วซึ่ง "ไม่ได้ติดตาม" ซึ่งเราไม่ต้องการเพิ่มในที่เก็บ Git ตอนนี้เราควรเห็นผลกระทบของไฟล์ .gitignore:

git status

สมบูรณ์แบบ! .gitignore +1 :)

การทำงานกับสาขาและอื่นๆ

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

git branch -a

คุณจะเห็นว่าเรามีสาขาหลักเพียงแห่งเดียว เครื่องหมายดอกจันข้างหน้าแสดงว่าเราอยู่ในนั้น อย่างไรก็ตาม คุณยังสามารถใช้คำสั่ง "git status" เพื่อดูว่าเราอยู่ในสาขาใด จากนั้นมีตัวเลือกมากมายสำหรับการสร้างสาขา (อาจมีมากกว่านี้ — นี่คือตัวเลือกที่ฉันใช้):

• สร้างสาขาใหม่ตามสาขาที่เราอยู่ (99% ของกรณี)
• สร้างสาขาตามการกระทำเฉพาะ (1% ของกรณี)

มาสร้างสาขาตามการกระทำเฉพาะ

เราจะใช้ตัวระบุเฉพาะของการกระทำ เพื่อค้นหาเราเขียน:

git log

ฉันได้เน้นการกระทำด้วยความคิดเห็น "เพิ่มสวัสดีชาวโลก..." ตัวระบุเฉพาะของมันคือ 6c44e53d06228f888f2f454d3cb8c1c976dd73f8 ฉันต้องการสร้างสาขา "การพัฒนา" ที่เริ่มต้นจากการกระทำนี้ ในการทำเช่นนี้ฉันเขียน:

git checkout -b development 6c44e53d06228f888f2f454d3cb8c1c976dd73f8

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

git status
git log

และตามที่คาดไว้ เรามีสองคอมมิชชัน อย่างไรก็ตาม ประเด็นที่น่าสนใจคือ ยังไม่มีไฟล์ .gitignore ในสาขานี้ ดังนั้นไฟล์ที่คอมไพล์แล้ว (GitTest.class) จึงถูกเน้นด้วยสถานะ "ไม่ติดตาม" ตอนนี้เราสามารถตรวจสอบสาขาของเราอีกครั้งโดยเขียนสิ่งนี้:

git branch -a

คุณจะเห็นว่ามีสองสาขา: "ต้นแบบ" และ "การพัฒนา" ขณะนี้เรากำลังอยู่ในระหว่างการพัฒนา

มาสร้างสาขาตามสาขาปัจจุบันกันเถอะ

วิธีที่สองในการสร้างสาขาคือสร้างจากสาขาอื่น ฉันต้องการสร้างสาขาตามสาขาหลัก ก่อนอื่น ฉันต้องเปลี่ยนไปใช้มัน และขั้นตอนต่อไปคือสร้างอันใหม่ ลองดู:

• git checkout master — เปลี่ยนเป็นสาขาหลัก
• git status — ยืนยันว่าเราอยู่ใน master branch จริงๆ

ที่นี่คุณจะเห็นว่าเราเปลี่ยนไปใช้สาขาหลัก ไฟล์ .gitignore มีผลบังคับใช้ และคลาสที่คอมไพล์แล้วจะไม่เน้นเป็น "untracked" อีกต่อไป ตอนนี้เราสร้างสาขาใหม่ตามสาขาหลัก:

git checkout -b feature/update-txt-files

หากคุณไม่แน่ใจว่าสาขานี้เหมือนกับ "master" หรือไม่ คุณสามารถตรวจสอบได้โดยดำเนินการ "git log" และดูที่คอมมิชชันทั้งหมด ควรมีสี่คน

แก้ปัญหาความขัดแย้ง

ก่อนที่เราจะสำรวจว่าความขัดแย้งคืออะไร เราต้องพูดถึงการรวมสาขาหนึ่งเข้ากับอีกสาขาหนึ่ง ภาพนี้แสดงขั้นตอนการรวมสาขาหนึ่งเข้ากับอีกสาขา: ที่นี่เรามีสาขาหลัก ในบางจุด สาขารองจะถูกสร้างขึ้นจากสาขาหลักและแก้ไขแล้ว เมื่อทำงานเสร็จแล้ว เราต้องรวมสาขาหนึ่งเข้ากับอีกสาขาหนึ่ง ฉันจะไม่อธิบายคุณสมบัติต่างๆ: ในบทความนี้ ฉันต้องการสื่อความเข้าใจทั่วไปเท่านั้น หากต้องการรายละเอียด คุณสามารถค้นหาได้ด้วยตนเอง ในตัวอย่างของเรา เราได้สร้างสาขาของฟีเจอร์/อัพเดต-txt-ไฟล์ ตามชื่อสาขา เรากำลังปรับปรุงข้อความ ตอนนี้เราต้องสร้างคอมมิชชันใหม่สำหรับงานนี้:

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

ตอนนี้ หากเราต้องการรวมสาขาของ feature/update-txt-files เข้ากับ master เราต้องไปที่ master และเขียน "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 อีกครั้ง แต่ตอนนี้ไฟล์นี้จะถูกเปลี่ยนในสาขาหลักเช่นกัน กล่าวอีกนัยหนึ่งก็จะเปลี่ยนขนานกันไป Git จะไม่สามารถทราบได้ว่าต้องทำอย่างไรเมื่อเราต้องการรวมรหัสใหม่ของเราเข้ากับสาขาหลัก ไปกันเถอะ! เราจะสร้างสาขาใหม่ตามต้นแบบ ทำการเปลี่ยนแปลง 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 ไม่สามารถตัดสินใจได้เองว่าจะรวมรหัสนี้อย่างไร มันบอกเราว่าเราต้องแก้ไขข้อขัดแย้งก่อน แล้วจึงดำเนินการกระทำเท่านั้น ตกลง. เราเปิดไฟล์ที่มีข้อขัดแย้งในโปรแกรมแก้ไขข้อความและดู: เพื่อให้เข้าใจว่า Git ทำอะไรที่นี่ เราต้องจำไว้ว่าเราทำการเปลี่ยนแปลงใดและที่ไหน จากนั้นจึงเปรียบเทียบ:

1. การเปลี่ยนแปลงที่อยู่ในบรรทัดนี้ในสาขาหลักจะอยู่ระหว่าง "<<<<<<< HEAD" และ "======="
2. การเปลี่ยนแปลงที่อยู่ในสาขาคุณลักษณะ/ส่วนเพิ่มส่วนหัวอยู่ระหว่าง "=======" และ ">>>>>>> คุณลักษณะ/ส่วนเพิ่มส่วนหัว"

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

git status

เราสามารถโน้มน้าวตนเองได้ว่านี่เป็นกรณีพิเศษและไม่ธรรมดา ดำเนินการต่อ:

git add *.txt

คุณอาจสังเกตเห็นว่าคำอธิบายแนะนำให้เขียนเฉพาะ "git commit" มาลองเขียนว่า:

git commit

และเช่นเดียวกับที่เราทำได้ เราแก้ไขข้อขัดแย้งในคอนโซล แน่นอนว่าสิ่งนี้สามารถทำได้ง่ายขึ้นเล็กน้อยในสภาพแวดล้อมการพัฒนาแบบบูรณาการ ตัวอย่างเช่น ใน IntelliJ IDEA ทุกอย่างได้รับการตั้งค่าอย่างดีเพื่อให้คุณสามารถดำเนินการที่จำเป็นทั้งหมดได้ภายในนั้น แต่ IDE ทำสิ่งต่างๆ มากมาย "ภายใต้ประทุน" และเรามักไม่เข้าใจว่าเกิดอะไรขึ้นที่นั่น และเมื่อขาดความเข้าใจก็จะเกิดปัญหาขึ้นได้

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

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

• GitHubเป็นแพลตฟอร์มการจัดเก็บข้อมูลที่ใหญ่ที่สุดสำหรับพื้นที่เก็บข้อมูลและการพัฒนาร่วมกัน ฉันได้อธิบายไปแล้วในบทความก่อนหน้านี้
  ติดตามฉันบนGitHub ฉันมักจะอวดผลงานของฉันที่นั่นในสาขาที่ฉันกำลังศึกษาอยู่

• GitLabเป็นเครื่องมือบนเว็บสำหรับ วงจรชีวิต ของDevOpsด้วยโอเพ่นซอร์ส เป็น ระบบที่ใช้ Gitสำหรับจัดการที่เก็บโค้ดด้วย wiki, ระบบติดตามบั๊ก , ไปป์ไลน์ CI/CD และฟังก์ชันอื่นๆ
  หลังจากมีข่าวว่า Microsoft ซื้อ GitHub นักพัฒนาบางรายก็ทำซ้ำโครงการของตนใน GitLab

• BitBucket เป็นบริการเว็บสำหรับการโฮสต์โครงการและการพัฒนาร่วมกันโดยใช้ระบบควบคุมเวอร์ชันของ Mercurial และ Git ครั้งหนึ่งมันมีข้อได้เปรียบเหนือ GitHub ตรงที่ให้พื้นที่เก็บข้อมูลส่วนตัวฟรี ปีที่แล้ว GitHub ยังแนะนำความสามารถนี้ให้กับทุกคนฟรี

• และอื่น ๆ ...

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

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

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

git pull

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

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

คำสั่งเพื่อส่งสิ่งนี้ไปยังที่เก็บระยะไกลคือ:

git push

นั่นคือทั้งหมดที่ฉันอยากจะพูด ขอบคุณสำหรับความสนใจ. ติดตามฉันบนGitHubที่ฉันโพสต์โครงการตัวอย่างเจ๋งๆ มากมายที่เกี่ยวข้องกับการเรียนส่วนตัวและงานของฉัน

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

• เอกสาร Gitอย่างเป็นทางการ ฉันแนะนำเป็นข้อมูลอ้างอิง