เริ่มต้นใช้งาน Git: คำแนะนำโดยละเอียดสำหรับผู้เริ่มต้น

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

สวัสดีอนาคตวิศวกรซอฟต์แวร์อาวุโส วันนี้เราจะพูดถึงระบบควบคุมเวอร์ชัน ซึ่งก็คือ Git (อ่านว่า GIT ไม่ใช่ JIT ซึ่งอาจดูเหมือนมาจากไวยากรณ์ภาษาอังกฤษ) ใช่ ใช่ ฉันรู้ว่ามี Mercurial, SVN... แต่ขอบอกตามตรงว่า เวลาของพวกเขาได้ผ่านไปแล้ว และฉันจะไม่เสียเวลาอันมีค่าของคุณไปกับพวกเขา เพื่อที่คุณจะได้เข้าใจถึงความสำคัญของการรู้จัก Git ในยุคของเรา ฉันจะพูดแบบนี้: หากไม่มีความรู้/ความเข้าใจในเรื่องนี้ คุณก็ไม่ต้องทำอะไรเลยในการเขียนโปรแกรม แต่ข้อดีก็คือการทำงานอย่างต่อเนื่อง คุณไม่จำเป็นต้องเก็บคำสั่งและความเป็นไปได้ทั้งหมดไว้ในหัว คุณจำเป็นต้องรู้ชุดคำสั่งที่จะช่วยให้คุณเข้าใจทุกสิ่งที่เกิดขึ้น

ข้อมูลพื้นฐานเกี่ยวกับ Git

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

การติดตั้ง Git

มาติดตั้ง Git บนคอมพิวเตอร์ของคุณกันดีกว่า ฉันเข้าใจว่าทุกคนมี OS ที่แตกต่างกัน ดังนั้นฉันจะพยายามอธิบายหลายกรณี

การติดตั้งสำหรับ Windows

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

การติดตั้งสำหรับ Linux

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

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

ที่นี่เช่นกัน ก่อนอื่นคุณต้องตรวจสอบว่ามี Git อยู่แล้วหรือไม่ (ดูด้านบน เช่นเดียวกับบน Linux) ถ้าไม่เช่นนั้น วิธีที่ง่ายที่สุดคือดาวน์โหลดเวอร์ชันล่าสุด หากติดตั้ง XCode แล้ว 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

Gita มีหลายรัฐที่ต้องเข้าใจและจดจำ:

• ไม่ได้ติดตาม;
• แก้ไข;
• เตรียมพร้อม (จัดฉาก);
• มุ่งมั่น.

มันหมายความว่าอะไร?

นี่คือสถานะที่มีไฟล์จากโค้ดของเราอยู่ นั่นคือเส้นทางชีวิตของพวกเขามักจะมีลักษณะดังนี้:

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

หน้าตาประมาณนี้ (ภาพจากเอกสารราชการจึงวางใจได้)):

การกระทำคืออะไร

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

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

นี่คือสิ่งที่ดูเหมือน:

สาขาอะไร

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

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

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

การทำงานกับ Git ในพื้นที่เก็บข้อมูลในเครื่อง

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

git init

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

git status

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

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

นั่นคือคุณจะเห็นได้ชัดเจนว่าฉันได้เพิ่ม Hello World! ลงในไฟล์ข้อความของเรา เพิ่มการเปลี่ยนแปลงในไฟล์ข้อความและคอมมิต:

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 ละเว้นจะมีลักษณะดังนี้:

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

ลองดูตอนนี้:

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

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

git status

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

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

และตอนนี้ช่วงเวลาแห่งความจริง: เรามีคลาส GitTest.class ที่คอมไพล์แล้วในสถานะที่ไม่ถูกติดตาม ซึ่งเราไม่ต้องการเพิ่มลงในที่เก็บ Git นี่คือจุดที่ git ละเว้นควรทำงาน:

git status

ทุกอย่างชัดเจน) Git เพิกเฉย +1)

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

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

git branch -a

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

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

สร้างสาขาตามการคอมมิตเฉพาะ

เราจะอาศัยตัวระบุการคอมมิตที่ไม่ซ้ำใคร หากต้องการค้นหาเราเขียนว่า:

git log

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

git checkout -b development 6c44e53d06228f888f2f454d3cb8c1c976dd73f8

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

git status
git log

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

git branch -a

จะเห็นได้ว่ามีสองสาขา - ปริญญาโทและการพัฒนา - และตอนนี้เรากำลังอยู่ในการพัฒนา

สร้างสาขาตามสาขาปัจจุบัน

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

• git checkout master - ย้ายไปที่สาขาหลัก
• สถานะ git - ตรวจสอบว่าอยู่บนต้นแบบหรือไม่

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

git checkout -b feature/update-txt-files

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

แก้ไขข้อขัดแย้ง

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

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

ตอนนี้ หากเราต้องการรวมสาขา features/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
... делаем изменения в файле

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”

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

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 ทุกอย่างได้รับการตั้งค่าอย่างดีจนคุณสามารถดำเนินการที่จำเป็นทั้งหมดได้ในนั้น แต่สภาพแวดล้อมการพัฒนาทำหน้าที่หลายอย่างภายใต้ประทุน และเรามักไม่เข้าใจว่าเกิดอะไรขึ้นที่นั่น และเมื่อไม่มีความเข้าใจ ปัญหาก็เกิดขึ้นได้

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

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

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

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

• BitBucket เป็นบริการเว็บสำหรับการโฮสต์โปรเจ็กต์และการพัฒนาร่วมกัน โดยใช้ระบบควบคุมเวอร์ชัน Mercurial และ Git ครั้งหนึ่งมีข้อได้เปรียบเหนือ 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 เป็นภาษารัสเซีย ผมขอแนะนำเป็นแนวทางครับ
• คอมไพล์