การใช้งาน GitHub คอมไพล์ การเริ่มต้นใช้งานการทำงานขั้นพื้นฐานอย่างรวดเร็วพร้อมคำอธิบาย ผลิตภัณฑ์และคุณสมบัติ

คอมไพล์ การเริ่มต้นใช้งานการทำงานขั้นพื้นฐานอย่างรวดเร็วพร้อมคำอธิบาย

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

Git push ต้นแบบต้นกำเนิด

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

โอ้ ใช่แล้ว สำหรับคนเจ๋งๆ ที่ทำงานกับเซิร์ฟเวอร์ (เช่น เหมาะที่จะพูดถึง GitHub) คำสั่งจะเป็นดังนี้:

Git เพิ่มต้นกำเนิดระยะไกล [เซิร์ฟเวอร์]

การแตกแขนง

ในภาษาอังกฤษสิ่งนี้เรียกว่า การแตกแขนง- ดีกว่าที่จะเจาะลึกปัญหานี้และอ่านรายละเอียดเพิ่มเติมเกี่ยวกับการแตกแขนง ฉันจะแนะนำให้คุณรู้จัก การแตกแขนงใช้สำหรับการพัฒนาคุณสมบัติต่าง ๆ พร้อมกันและเป็นอิสระ (ดีหรือการสะสมข้อบกพร่องมากขึ้นเนื่องจากมีซอร์สโค้ดมากกว่า) สาขาหลักคือ ผู้เชี่ยวชาญ- จะปรากฏขึ้นเมื่อสร้างพื้นที่เก็บข้อมูล แบรนช์อื่นๆ จะเป็นแซนด์บ็อกซ์ เมื่อคุณเล่นมามากพอแล้ว ให้รวมมันเข้าด้วยกันเป็นอันเดียวในมาสเตอร์ ตอนนี้ฉันจะอธิบายวิธีการทำสิ่งนี้

กำลังสร้างสาขาใหม่

คุณจึงตัดสินใจที่จะใช้งานฟีเจอร์ใหม่บางอย่าง สร้างสาขาใหม่สำหรับมัน:

Git ชำระเงิน -b [new_branch]

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

การสลับระหว่างสาขา

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

Git ชำระเงิน [ที่เก็บ]/[สาขา]

ถ้าคุณไม่ต้องการทำงานกับมันเลยให้ลบมันออกทั้งหมด:

สาขา Git -d [สาขา]

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

Git push origin [สาขา]

การรวมสาขา

หากต้องการรวมสาขาเข้ากับสาขาที่คุณกำลังดำเนินการอยู่ ให้ใช้:

Git ผสาน [สาขา]

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

Git เพิ่ม [ชื่อไฟล์]

โดยวิธีการนี้สามารถเปรียบเทียบสาขาได้:

Git diff [one_branch] [other_branch]

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

ดึง Git

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

แท็ก Git [first_ten_ตัวละครของ the_corresponding_commit]

คุณไม่ทราบว่าอักขระตัวแรกในชื่อของการคอมมิตที่ต้องการคืออะไร? ไม่มีปัญหา ดูประวัติของพื้นที่เก็บข้อมูล - บันทึก:

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

ให้ตายเถอะ ฉันทำอะไรผิดไป!

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

ชำระเงิน Git -- [ชื่อไฟล์]

แต่หากปัญหาอยู่ในพื้นที่เก็บข้อมูลในเครื่องแล้ว ให้ล้างข้อมูลทั้งหมดที่นั่นและส่งคืนเวอร์ชันจากเซิร์ฟเวอร์:

Git fetch origin git reset --hard origin/master

ใช่เพื่อน ทุกอย่างยากที่นี่ นี่คือคอมไพล์

คุณสมบัติคอมไพล์

หากคุณขี้เกียจและไม่ต้องการเขียนทุกอย่างลงในเชลล์ระบบปฏิบัติการของคุณ คุณสามารถใช้ GUI ของ Git ได้:

คุณจะพบกับ GUI อื่นๆ มากมาย
หากคุณพบว่าเอาต์พุตมาตรฐานของ git น่าเบื่อ ให้เติมสี:

Git config color.ui จริง

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

Git เพิ่ม -i

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

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

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

ตามธรรมเนียม ก่อนที่จะไปยังตัวอย่างและทำงานกับคำสั่ง มาดูตัวเลือกและพารามิเตอร์หลักกันก่อน ไวยากรณ์ git นั้นง่ายมาก:

อาร์กิวเมนต์คำสั่งตัวเลือก $ git

ก่อนอื่นเรามาดูตัวเลือกต่างๆ กันก่อน ซึ่งจะส่งผลต่อการทำงานของยูทิลิตี้ทั้งหมด:

• -ค- ใช้โฟลเดอร์ที่เก็บที่ระบุแทนโฟลเดอร์ปัจจุบัน
• -ค พารามิเตอร์=ค่า- ใช้ค่าพารามิเตอร์การกำหนดค่าที่ระบุ
• -พี- เลื่อนดูผลลัพธ์ทั้งหมดโดยใช้น้อยลง

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

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

อาร์กิวเมนต์ขึ้นอยู่กับคำสั่งที่ใช้ ดังนั้นเราจะดูรายละเอียดเพิ่มเติมในตัวอย่าง

คอมไพล์ทำงานอย่างไร?

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

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

วิธีการใช้งาน Git?

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

การสร้างโครงการ

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

mkdir -p ~/git/การทดสอบ ; ซีดี ~/git/testing

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

โปรเจ็กต์พร้อมแล้ว แต่ระบบควบคุมเวอร์ชัน git ยังไม่รู้

การตั้งค่าโปรเจ็กต์ใน git

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

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

หากทุกอย่างเป็นไปด้วยดี คำสั่งจะไม่แสดงสิ่งใดออกมา

กำลังดำเนินการเปลี่ยนแปลง

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

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

git กระทำ -m "ความมุ่งมั่นเริ่มต้น" -a

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

git commit -m ไฟล์ "ไฟล์ที่เปลี่ยนแปลง"

กำลังส่งการเปลี่ยนแปลง

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

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

git ระยะไกลเพิ่มต้นทาง https://github.com/Seriyyy95/testing.git

จากนั้นคุณสามารถดูรายการพื้นที่เก็บข้อมูลระยะไกลได้:

คุณสามารถใช้ได้ไม่เพียงแต่เซิร์ฟเวอร์ GitHub เท่านั้น แต่ยังรวมถึงเซิร์ฟเวอร์อื่นๆ อีกด้วย ตอนนี้เพื่อส่งการเปลี่ยนแปลงของคุณให้ใช้คำสั่งนี้:

git push ต้นแบบต้นกำเนิด

คำสั่ง push ระบุว่าเราต้องการส่งข้อมูลไปยังพื้นที่เก็บข้อมูลระยะไกล origin คือพื้นที่เก็บข้อมูลที่เรากำหนดค่าไว้ และ master คือสาขา

การจัดการสาขา

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

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

git checkout -b พัฒนา

คุณยังสามารถสลับระหว่างสาขาโดยใช้คำสั่งเดียวกัน:

git ชำระเงินต้นแบบ
$ git ชำระเงินพัฒนา

ตอนนี้เรามาสร้างไฟล์อื่น:

และเพิ่มลงในสาขาพัฒนาใหม่ของเรา:

มายืนยันการเปลี่ยนแปลงที่ทำ:

git commit -m "พัฒนาไฟล์" พัฒนา

สาขาคอมไพล์
$ls

จากนั้นสลับไปที่สาขาหลักแล้วดูอีกครั้ง:

git ชำระเงินต้นแบบ
สาขา $git
$ls

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

git Merge พัฒนา --no-ff

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

ข้อสรุป

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

หลายๆ คนคงเคยได้ยินเกี่ยวกับระบบควบคุมเวอร์ชัน git มาก่อน วันนี้เราจะดูเส้นทางทั้งหมดตั้งแต่การติดตั้ง git ไปจนถึงการเปลี่ยนแปลงพื้นที่เก็บข้อมูลระยะไกลโดยใช้ไลบรารี OsEngine เป็นตัวอย่าง ขั้นแรก ให้ดาวน์โหลดไคลเอ็นต์ git จากลิงก์แล้วติดตั้ง จะไม่มีคำถาม
ควรคลิกถัดไปทุกที่ ต่อไป จะมีการหารือเกี่ยวกับการโต้ตอบกับ git โดยใช้ตัวอย่างการทำงานกับคอนโซลไคลเอ็นต์ ขั้นตอนต่อไปคือการลงทะเบียนบนเว็บไซต์ https://github.com/ ตอนนี้เราสามารถเริ่มทำงานกับ OsEngine ได้แล้ว หากต้องการทำสิ่งนี้ ให้ไปที่พื้นที่เก็บข้อมูลโปรเจ็กต์แล้วคลิกปุ่มแยกที่มุมขวาบน

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

$ git clone "วางลิงก์ที่นี่โดยไม่มีเครื่องหมายคำพูด"

กระบวนการคัดลอกที่เก็บระยะไกลไปยังโลคัลจะเริ่มต้นขึ้นและสำเนาการทำงานชื่อ OsEngine จะปรากฏในโฟลเดอร์ปัจจุบัน

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

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

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

$ git config --global user.name “ชื่อของคุณ”
$ git config --global user.email “อีเมลของคุณ”

คุณสามารถดูไฟล์คอนฟิกูเรชันได้ด้วยคำสั่ง:

$ git config --global --list

ทำงานกับสาขา

สาขาใน git นั้นเหมือนกับสาขาใน github หากต้องการสร้างสาขาใหม่ ให้รันคำสั่งในคอนโซล:

$ git สาขาชื่อที่ต้องการ

หากต้องการเปลี่ยนไปใช้สาขานี้ให้รันคำสั่ง:

ชื่อสาขาการชำระเงิน $ git

หากต้องการกลับไปยังสาขาหลัก ให้พิมพ์:

$git ต้นแบบการชำระเงิน

เปลี่ยนชื่อสาขา:

$ git สาขา – ชื่อใหม่

ทีม สาขา $git ทำให้เราทราบได้ว่าตอนนี้เราอยู่ในสาขาไหน คำสั่งลบสาขา

สาขา $git –D ชื่อสาขา

การรวมสาขาเข้ากับสาขาหลักทำได้ด้วยคำสั่ง:

$ git รวมชื่อสาขา

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

มุ่งมั่น

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

การเพิ่มไฟล์ลงในดัชนี

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

$git เพิ่ม README

และไฟล์ README จะถูกเพิ่มลงในดัชนี หากคุณต้องการสร้างดัชนีไฟล์ที่อัปเดตและไฟล์ใหม่ทั้งหมด ให้ดำเนินการ

$git เพิ่ม

โปรดทราบว่ามีจุดที่ท้ายและมีช่องว่างข้างหน้า

การลบไฟล์ออกจากดัชนี

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

$git รีเซ็ต README

หากคุณเปลี่ยนใจที่จะทิ้งการเปลี่ยนแปลงที่ทำไว้กับไฟล์ไว้ ให้รันคำสั่ง

$ git checkout -- ชื่อไฟล์

และจะกลับสู่สถานะเดิมในระหว่างการคอมมิตครั้งล่าสุด เพียงจำไว้ว่าการเปลี่ยนแปลงทั้งหมดในไฟล์นี้จะหายไป

การสร้างคอมมิต

ตอนนี้คุณสามารถคอมมิตการเปลี่ยนแปลงได้โดยใช้คำสั่ง:

$ git commit –m “ควรมีความคิดเห็นในเครื่องหมายคำพูดที่นี่”

ควรจำไว้ว่าการมีความคิดเห็นเป็นสิ่งจำเป็นเบื้องต้น สามารถดูประวัติการเปลี่ยนแปลงได้ด้วยคำสั่ง

บันทึก $git

$git แสดง จะแสดงเฉพาะการเปลี่ยนแปลงล่าสุดเท่านั้น หากต้องการออกจากโหมดการเล่น ให้กด q

Git มีความสามารถในการจัดทำดัชนีการเปลี่ยนแปลงทั้งหมดและคอมมิตด้วยคำสั่งเดียว:

$ git กระทำ –a –m “ความคิดเห็นในเครื่องหมายคำพูด”

วิธีการ: เพิ่มการเปลี่ยนแปลงทั้งหมดลงในดัชนีก่อนโอน
-m: ความคิดเห็น

การแก้ไข การลบ การดำเนินการ

หากคุณต้องการยกเลิกการคอมมิตครั้งล่าสุด ให้ใช้คำสั่ง:

$ git เปลี่ยนกลับ HEAD

คอมมิตจะนับจาก 0 โดยเริ่มจากอันสุดท้าย ตัวอย่างเช่น หากคุณต้องการยกเลิกการคอมมิตครั้งที่ 3 คุณควรรัน:

$ git เปลี่ยนกลับ HEAD~2

ทีม $ git รีเซ็ต --soft HEAD~3 จะลบการคอมมิต 3 รายการสุดท้ายและย้อนกลับโปรเจ็กต์เป็นสถานะของการคอมมิตครั้งที่สี่ ในขณะที่เก็บการเปลี่ยนแปลงทั้งหมดจากการคอมมิตสามรายการล่าสุดไว้ในดัชนี

$ git รีเซ็ต -- ฮาร์ด HEAD~3

จะลบการคอมมิตสามรายการสุดท้ายออกโดยสมบูรณ์

สถานะไฟล์

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

ทำการเปลี่ยนแปลงในเครื่องกับที่เก็บระยะไกล

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

$git ต้นแบบการพุช

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

$git ดึง

การใช้คีย์ SSH

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

$ssh-keygen

จากนั้นกด Enter 3 ครั้งและอยู่ในไดเร็กทอรีเริ่มต้น C:\Users\ชื่อผู้ใช้\.sshโฟลเดอร์ที่มีปุ่มจะปรากฏขึ้น จำเป็นต้องเปิดไฟล์
id_rsa พิมพ์ PUB ในโปรแกรมแก้ไขข้อความและคัดลอกเนื้อหา จากนั้นไปที่ GitHub ในการตั้งค่าบัญชีของคุณ

จากนั้นในคอลัมน์ด้านซ้ายเลือกรายการ: คีย์ SSH และ GPG แล้วคลิกปุ่มสีเขียวทางด้านขวาของคีย์ SSH ใหม่

ตั้งชื่อเรื่อง ใส่ข้อมูลที่คัดลอกมาจากคีย์ลงในฟิลด์คีย์แล้วคลิก

การรวมสาขาบน GitHub

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

แล้ว

ในบทความนี้ เราได้ดูคำสั่ง git พื้นฐาน ซึ่งเพียงพอที่จะเริ่มทำงานกับโปรเจ็กต์ OsEngine โดยใช้ git และบริการ github

มีความสุขในความมุ่งมั่น!

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

ผู้คนมักพูดว่า Git นั้นยากเกินไปสำหรับผู้เริ่มต้น อย่างไรก็ตาม ผมขอแย้งเรื่องนี้

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

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

เราจะไม่พูดถึงส่วนที่ค่อนข้างซับซ้อนของ Git เช่น การแยกย่อย เนื่องจากบทช่วยสอนนี้มีไว้สำหรับผู้เริ่มต้น

การติดตั้ง Git

บนเว็บไซต์ Git อย่างเป็นทางการมี รายละเอียดข้อมูลเกี่ยวกับการติดตั้งบน Linux, Mac และ Windows ในกรณีของเรา เราจะใช้ Ubuntu 13.04 เพื่อการสาธิต โดยเราจะติดตั้ง Git โดยใช้ apt-get:

sudo apt-get ติดตั้งคอมไพล์

ตั้งค่าเริ่มต้น

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

mkdir my_git_project ซีดี my_git_project

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

git config --global user.name "Shaumik" git config --global user.email " [ป้องกันอีเมล]" git config --global color.ui "อัตโนมัติ"

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

นอกจากนี้เรายังตั้งค่าสี UI เป็น auto ซึ่งจะทำให้เอาต์พุตของคำสั่ง Git มีรหัสสี

คำนำหน้า --global หน้าคำสั่งเพื่อหลีกเลี่ยงการต้องป้อนคำสั่งการกำหนดค่าเหล่านี้ในครั้งถัดไปที่เรารันโปรเจ็กต์ Git บนระบบของเรา

การเตรียมไฟล์สำหรับการคอมมิต

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

ตรวจสอบสถานะพื้นที่เก็บข้อมูล

ตอนนี้เรามีไฟล์จำนวนหนึ่งอยู่ใน repository ของเราแล้ว เรามาดูกันว่า Git จัดการกับมันอย่างไร ในการตรวจสอบสถานะปัจจุบันของที่เก็บ คุณต้องใช้คำสั่ง git status:

การเพิ่มไฟล์ลงใน Git เพื่อการติดตาม

เราไม่มีไฟล์ใดๆ ที่จะติดตามด้วย Git ในขณะนี้ เราจำเป็นต้องเพิ่มไฟล์ลงใน Git โดยเฉพาะเพื่อที่จะบอก Git ว่าจะติดตามอะไร

เพิ่มไฟล์โดยใช้คำสั่ง add:

เมื่อตรวจสอบสถานะพื้นที่เก็บข้อมูลอีกครั้ง เราจะเห็นว่ามีการเพิ่มไฟล์หนึ่งไฟล์:

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

git เพิ่ม myfile2 myfile3

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

หากคุณใช้คำสั่ง add ซ้ำๆ คำสั่งจะเพิ่มไฟล์ดังกล่าวทั้งหมดหากมีอยู่ในที่เก็บของคุณ

กำลังลบไฟล์

แต่การรันคำสั่ง git rm แบบง่ายๆ จะไม่เพียงแต่ลบไฟล์ออกจาก Git เท่านั้น แต่ยังรวมถึงระบบไฟล์ในเครื่องของคุณด้วย! ถึง

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

git rm --แคช

ยอมรับการเปลี่ยนแปลง

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

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

git commit -m "การกระทำครั้งแรกของฉัน"

ส่งข้อความที่เป็นประโยชน์ต่อ Commit ของคุณเพราะสิ่งนี้จะช่วยให้คุณระบุสิ่งที่คุณเปลี่ยนแปลงใน Commit นั้น

หลีกเลี่ยงข้อความที่กว้างเกินไป เช่น " แก้ไขข้อบกพร่องแล้ว- หากคุณมีตัวติดตามงาน คุณสามารถเพิ่มข้อความเช่น " แก้ไขข้อผิดพลาด #234».

แนวปฏิบัติที่ดีคือใช้ชื่อสาขาหรือชื่อคุณสมบัติเป็นคำนำหน้าข้อความคอมมิต ตัวอย่างเช่น, " การจัดการสินทรัพย์: เพิ่มฟังก์ชันเพื่อสร้างไฟล์ PDF ของสินทรัพย์” เป็นข้อความที่มีความหมาย

Git ระบุการคอมมิตโดยการเพิ่มเลขฐานสิบหกแบบยาวให้กับแต่ละคอมมิต ตามกฎแล้ว คุณไม่จำเป็นต้องคัดลอกทั้งบรรทัด อักขระ 5-6 ตัวแรกก็เพียงพอที่จะระบุการคอมมิตของคุณ

โปรดทราบว่าในภาพหน้าจอการคอมมิตครั้งแรกของเราถูกกำหนดโดยรหัส 8dd76fc

กระทำเพิ่มเติม

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

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

คุณต้องเพิ่มไฟล์เหล่านี้อีกครั้งเพื่อทำการเปลี่ยนแปลงไฟล์ที่ถูกติดตามสำหรับการส่งครั้งถัดไป คุณสามารถเพิ่มไฟล์ที่ถูกติดตามทั้งหมดได้โดยการรันคำสั่ง:

คุณสามารถหลีกเลี่ยงการใช้คำสั่งนี้ได้โดยใช้คำนำหน้า -a ของคำสั่ง git commit ซึ่งจะเพิ่มการเปลี่ยนแปลงทั้งหมดให้กับไฟล์ที่ติดตาม

อย่างไรก็ตาม กระบวนการนี้มีอันตรายมากเนื่องจากอาจเป็นอันตรายต่อโครงการได้ ตัวอย่างเช่น สมมติว่าคุณเปิดไฟล์แล้วเปลี่ยนแปลงโดยไม่ได้ตั้งใจ

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

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

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

การจัดการโครงการ

หากต้องการดูประวัติโครงการของคุณ คุณสามารถเรียกใช้คำสั่งต่อไปนี้:

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

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

คอมไพล์แสดง

ที่ไหน นี่คือเลขฐานสิบหกที่เกี่ยวข้องกับการคอมมิต เนื่องจากบทช่วยสอนนี้มุ่งเป้าไปที่ผู้เริ่มต้น เราจะไม่ครอบคลุมวิธีการกลับไปสู่สถานะของการคอมมิตเฉพาะหรือวิธีจัดการสาขา

รหัสโฮสติ้งในระบบคลาวด์

เมื่อคุณได้เรียนรู้วิธีจัดการโค้ดบนระบบของคุณแล้ว ก็ถึงเวลาโฮสต์โค้ดในระบบคลาวด์

ระบบควบคุมเวอร์ชันแบบกระจาย (DVCS) จะค่อยๆ เข้ามาแทนที่ระบบควบคุมแบบรวมศูนย์ หากคุณยังไม่ได้ใช้หนึ่งในนั้น ตอนนี้เป็นเวลาที่จะลอง

ในบทความนี้ ฉันจะพยายามแสดงให้เห็นว่าคุณสามารถเริ่มทดลอง git ได้อย่างรวดเร็วโดยใช้เว็บไซต์ github.com ได้อย่างไร

บทความนี้จะไม่กล่าวถึงความแตกต่างระหว่าง DVCS ที่แตกต่างกัน นอกจากนี้ การทำงานกับ git จะไม่ถูกกล่าวถึงโดยละเอียด มีแหล่งข้อมูลดีๆ มากมายในหัวข้อนี้ ซึ่งฉันจะให้ไว้ในตอนท้ายของบทความ

ดังนั้น ไซต์ github.com จึงถูกวางตำแหน่งเป็นบริการโฮสต์โครงการเว็บโดยใช้ระบบควบคุมเวอร์ชัน git รวมถึงเครือข่ายโซเชียลสำหรับนักพัฒนา ผู้ใช้สามารถสร้างพื้นที่เก็บข้อมูลได้ไม่จำกัดจำนวน โดยแต่ละแห่งมีวิกิ ระบบติดตามปัญหา ความสามารถในการดำเนินการตรวจสอบโค้ด และอื่นๆ อีกมากมาย ปัจจุบัน GitHub เป็นบริการที่ได้รับความนิยมมากที่สุด แซงหน้า Sourceforge และ Google Code

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

เริ่มต้นด้วยการลงทะเบียน ไปที่ลิงก์ github.com/signup/free แล้วป้อนข้อมูลของคุณ
หลังจากลงทะเบียน เราจะถูกนำไปที่แดชบอร์ดของบัญชีของเรา:

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

แต่ก่อนอื่น มาติดตั้ง git และกำหนดค่าให้ทำงานกับไซต์ก่อน

หากคุณทำงานบน Windows ให้ดาวน์โหลดและติดตั้ง msysgit นี่คือ git เวอร์ชันคอนโซลสำหรับ Windows (เรื่องราวเพิ่มเติมจะขึ้นอยู่กับตัวอย่างของระบบปฏิบัติการนี้)
คำแนะนำสำหรับ MacOS X (อังกฤษ)
คำแนะนำสำหรับ Linux (อังกฤษ)
ไม่น่าจะมีปัญหา เพียงคลิกถัดไปทุกที่ หลังการติดตั้ง ให้เลือกจากเมนูบริบท Git Bash Explorer:

หรือผ่าน Git Bash.lnk ในโฟลเดอร์ที่ติดตั้งโปรแกรมไว้:

เราป้อนข้อมูลและการตั้งค่าตัวแบ่งบรรทัดในคอนโซล:
git config --global user.name "ชื่อของคุณ"
git config --global user.email "อีเมลของคุณ"
git config --global core.autocrlf จริง
git config --global core.safecrlf จริง

อย่างไรก็ตาม ฉันแนะนำให้เรียนหลักสูตรเชิงโต้ตอบที่ดีเกี่ยวกับการใช้ git จากคอนโซล หลักสูตรนี้จะเสร็จสิ้นภายในไม่กี่ชั่วโมงและมอบทักษะพื้นฐานที่จำเป็น

สำหรับผู้ที่ชื่นชอบ gui มีเครื่องมือหลายอย่างสำหรับการทำงานกับ git บน Windows สองสิ่งหลักคือ SmartGit (ข้ามแพลตฟอร์ม) และ TortoiseGit ดีทั้งสองอย่างและอันไหนที่จะใช้ก็เป็นเรื่องของรสนิยม ฉันจะอธิบายการทำงานกับ TortoiseGit
สำหรับดอกป๊อปปี้ก็มีตัวเลือกของ giu ด้วย

• ลูกค้าอย่างเป็นทางการจาก GitHub ยังค่อนข้างหยาบคายในความคิดของฉัน
• GitX - โดยส่วนตัวแล้วฉันไม่ชอบมัน
• GitBox - ส่วนใหญ่เป็นไปตาม mac-way ฉันขอแนะนำให้ลองใช้

เกี่ยวกับคอมไพล์ในภาษารัสเซีย:
habrahabr.ru/blogs/Git/106912 “ โมเดลการแตกแขนงที่ประสบความสำเร็จสำหรับ git” - การแปลบทความภาษาอังกฤษที่ดี
หลักสูตรเชิงโต้ตอบ githowto.com เกี่ยวกับการทำงานกับ git จากคอนโซล
habrahabr.ru/blogs/Git/106912 “ทำไมต้องคอมไพล์” + การสนทนา
habrahabr.ru/blogs/development/68341 “ Git สำหรับผู้ที่ย้ายจาก SVN” + การสนทนา