สวัสดีฮับ ฉันตัดสินใจที่จะกล่าวถึงหัวข้อที่หมดลงในบทความจำนวนมาก โดยเฉพาะอย่างยิ่งเพื่ออธิบายการใช้ระบบควบคุมเวอร์ชันที่ไม่ได้มาตรฐาน (ฉันจะบอกว่าไม่มีการเรียงลำดับ) (ต่อไปนี้จะเรียกว่า VCS) เพื่อนโปรแกรมเมอร์มาซ่อนมะเขือเทศเน่าแล้วเดินหน้าต่อไปเพราะบทความนี้ไม่เหมาะกับคุณ ใช่แล้ว พวกคุณทุกคนได้เรียนรู้ความซับซ้อนทั้งหมดของ Git, SVN, CVS และรู้จักคำศัพท์อื่นๆ อีกมากมายแล้ว ขอให้พวกเราซึ่งเป็นมนุษย์ปุถุชนทำความคุ้นเคยกับข้อดีทั้งหมดของการใช้สกุลเงินแข็ง
ฉันขอเชิญชวนทุกคนที่ต้องการทำความคุ้นเคยกับระบบสกุลเงินแข็ง รวมถึงผู้ที่จัดการกับข้อมูลที่เปลี่ยนแปลงอย่างรวดเร็วไม่ทางใดก็ทางหนึ่ง

เหตุใดจึงจำเป็น?

ฉันเป็นนักศึกษาในมหาวิทยาลัยเทคนิคและทำงานกับเอกสารเกือบตลอดเวลา (ข้อความ ภาพวาด ภาพวาด) โดยเปลี่ยนเอกสารเหล่านี้สาม (สิบหนึ่งร้อย) ครั้งต่อวัน บางครั้งปรากฎว่ามีการแก้ไขเกิดขึ้นระหว่างนั้น อาทิตย์ที่แล้วจำเป็นต้องยกเลิกและส่งคืนเอกสารในสภาพเมื่อสัปดาห์ที่แล้ว จะเป็นการดีหากมีการแก้ไขเพียงไม่กี่ครั้ง ซึ่งในกรณีนี้การคลิก Ctrl+Z ห้าสิบครั้งสามารถช่วยได้ อย่างไรก็ตาม หากในระหว่างสัปดาห์นี้มีงานในเอกสารไม่มากก็น้อย คุณจะไม่สามารถกู้คืนสถานะ "ก่อนการแก้ไขที่สำคัญเมื่อสัปดาห์ที่แล้ว" ได้ ในการดำเนินการนี้ คุณต้องมีสำเนาของเอกสารในขณะนั้น “ก่อนการแก้ไขที่สำคัญ” รวมถึงสำเนาอีกนับสิบชุด “ก่อนการแก้ไขที่สำคัญอีกครั้ง” “ก่อนการแก้ไขที่น่าสงสัย” และ “ก่อนการแก้ไขที่จะได้รับผลกระทบมากที่สุด คงต้องเลิกทำเสียแล้ว” โดยหลักการแล้ว แนวทางนี้เป็นไปได้และหลายๆ คนก็ปฏิบัติกัน จนกระทั่งเมื่อไม่นานมานี้ฉันเองก็ถือ รุ่นที่สำคัญบันทึกไฟล์เหล่านั้นด้วยคำนำหน้า "date_time" และดูเหมือนว่าฉันจะมีความสุข ข้อดีของวิธีนี้คือความเรียบง่ายข้อเสียคือโฟลเดอร์ทำงาน "บวม" และไม่สะดวกในการใช้งาน และหากสามารถจัดการสิ่งแรกได้ (ฮาร์ดไดรฟ์ขนาดใหญ่และ 7zip) ก็ต้องดำเนินการบางอย่างเกี่ยวกับความไม่สะดวก

สิ่งที่สามารถทำได้เกี่ยวกับเรื่องนี้หรือ SLE คืออะไร

มาดูย่อหน้าจาก Wikipedia: “ระบบควบคุมเวอร์ชัน (จากระบบควบคุมเวอร์ชันภาษาอังกฤษ, VCS หรือระบบควบคุมการแก้ไข) เป็นซอฟต์แวร์ที่อำนวยความสะดวกในการทำงานกับข้อมูลที่เปลี่ยนแปลง ระบบควบคุมเวอร์ชันช่วยให้คุณสามารถจัดเก็บเอกสารเดียวกันได้หลายเวอร์ชัน และหากจำเป็น ก็สามารถกลับไปใช้เวอร์ชันอื่นได้ รุ่นก่อนหน้ากำหนดว่าใครและเมื่อใดที่ทำการเปลี่ยนแปลงนี้ และอื่นๆ อีกมากมาย” มันคล้ายกับวิธีการทำงานของวิกิพีเดีย – บทความทุกเวอร์ชันที่มีการแก้ไขทั้งหมดพร้อมให้ศึกษา
ดังนั้น การใช้ VCS ในสถานการณ์ที่คุณต้องการจัดเก็บไฟล์หลายเวอร์ชันจึงเป็นสิ่งที่คุณต้องการ ข้อดีของวิธีนี้ ได้แก่ ใช้งานง่ายและประหยัดค่าใช้จ่ายฟรี พื้นที่ดิสก์ต้องขอบคุณสิ่งที่เรียกว่าการบีบอัดเดลต้า (เมื่อไม่ใช่ไฟล์ที่บันทึกในเวอร์ชันที่แตกต่างกัน แต่เปลี่ยนจากเวอร์ชันหนึ่งไปอีกเวอร์ชันหนึ่งซึ่งจะลดปริมาณข้อมูลที่เก็บไว้) มาลองกัน.

สกุลเงินแข็งมีประเภทใดบ้าง?

วิกิพีเดียเดียวกันนี้แนะนำว่าสกุลเงินแข็งสามารถรวมศูนย์และกระจายได้ ทั้งขนาดใหญ่และขนาดเล็ก โดยมีหรือไม่มีกระดิ่งและนกหวีดก็ได้ เราไม่สนใจเรื่องนี้เป็นพิเศษ เนื่องจากเราจะใช้ (by อย่างน้อยขั้นแรก) เพียงส่วนหนึ่งของฟังก์ชันการทำงานของระบบแลกเปลี่ยนสกุลเงิน ลองพิจารณาฟังก์ชันการทำงานนี้ดู
VCS เกือบทั้งหมดเป็นที่เก็บข้อมูลบางประเภทซึ่งจัดเก็บไฟล์ทุกเวอร์ชันที่เราทำงานด้วย มีความจำเป็นต้องชี้แจงในที่นี้ว่าเวอร์ชันของไฟล์ที่จัดเก็บมักถูกกำหนดโดยผู้ใช้ เราทำการเปลี่ยนแปลงเล็กๆ น้อยๆ มากมายและตัดสินใจว่าถึงเวลาที่จะบันทึกผลลัพธ์ของกิจกรรมของเราในพื้นที่เก็บข้อมูล มีความคล้ายคลึงกันเมื่อกด Ctrl+S เป็นระยะๆ โดยมีข้อแตกต่างเพียงอย่างเดียวคือไฟล์เวอร์ชันนี้สามารถเข้าถึงได้ในอนาคต โดยปกติแล้ว ในคราวเดียว คุณสามารถเพิ่มเวอร์ชันของไฟล์ได้มากเท่าที่คุณต้องการลงในที่เก็บ การดำเนินการนี้เรียกว่า "กระทำ" หรือ "ยอมรับการเปลี่ยนแปลง" ด้วยวิธีง่ายๆ
คุณสามารถเพิ่มหรือลบรายการใหม่ไปยังพื้นที่เก็บข้อมูลได้ตลอดเวลา (นั่นคือสิ่งที่เรียกว่าพื้นที่เก็บข้อมูลอย่างชาญฉลาด) ไฟล์ที่มีอยู่และ VCS จะ "จดจำ" เมื่อใดและสิ่งที่เราเพิ่ม/ลบ และต้องขอบคุณความคิดเห็นระหว่างการคอมมิต คุณยังสามารถอธิบายว่าทำไมการคอมมิตนี้จึงถูกดำเนินการ (“เพิ่มสิ่งประดับตรงนั้น”/“ลบชิ้นส่วนที่อาจจำเป็นออกจากที่นั่น”)
ในที่สุดเมื่อเราตระหนักได้ว่าถึงเวลาที่เราต้องกลับไปใช้เวอร์ชันจากสัปดาห์ที่แล้ว เราก็มีประวัติการเปลี่ยนแปลงทั้งหมด และที่นี่เราสามารถเลือกได้ว่าจะทำอะไร หากคุณต้องการคัดลอกส่วนที่ต้องการจากไฟล์เก่าและวางลงในเวอร์ชันปัจจุบัน เพียงลบไฟล์เก่าออกจากที่จัดเก็บข้อมูลและคัดลอกสิ่งที่คุณต้องการจากไฟล์นั้น หากจำเป็นต้องย้อนกลับโดยสมบูรณ์และทำงานต่อด้วย เวอร์ชั่นเก่า SKB มาช่วยเหลือเราอีกครั้ง - คุณสามารถกลับไปใช้เวอร์ชันก่อนหน้าและสร้างสิ่งที่เรียกว่าสาขาใหม่ ("สาขา") ในขณะที่ยังคงรักษาทุกสิ่งที่เรา "ละทิ้ง" ไว้โดยการย้อนกลับเวอร์ชันเมื่อสัปดาห์ที่แล้ว ดังนั้นประวัติของเวอร์ชันโครงการสามารถแสดงเป็นแผนภูมิแบบกราฟิกได้ตั้งแต่ "ราก" (จุดเริ่มต้นของโครงการ) ไปจนถึง "สาขา" (การแก้ไขที่สำเร็จและไม่สำเร็จ) นอกจากนี้ "สาขา" ยังสามารถสร้างปลอมได้ เช่น ในกรณีที่เราตัดสินใจพัฒนาสองไฟล์จากไฟล์ต้นฉบับเดียวกัน รุ่นที่แตกต่างกัน– ในตอนแรกเราทำงานกับเครื่องประดับบางอย่าง และในวินาทีที่เราทำงานกับเครื่องประดับอื่นๆ นอกจากนี้หากไฟล์งานมี เอกสารข้อความ(และในบางสาขา) เป็นไปได้ที่จะรวมสาขาต่าง ๆ เข้าด้วยกัน - ที่เรียกว่าการผสาน ทีนี้ลองจินตนาการว่ามีหลายคนกำลังทำงานในโครงการนี้ และทุกคนก็ทำ "เครื่องประดับ" ของตัวเอง การมีที่เก็บข้อมูลร่วมในกรณีนี้ทำให้การพัฒนาง่ายขึ้นอย่างมาก

จากทฤษฎีสู่การปฏิบัติหรือเริ่มใช้ SLE

ฉันหวังว่าฉันจะทำให้คุณมั่นใจว่าการใช้ SLE เป็นสิ่งที่ดี สิ่งที่เหลืออยู่คือการเรียนรู้วิธีใช้ VCS นี่คือสิ่งที่เราจะทำ
มีระบบควบคุมเวอร์ชันต่างๆ ที่แตกต่างกัน ด้านต่างๆใช้. เนื่องจากเราไม่สนใจ (อย่างน้อยในตอนแรก) ในรายละเอียดปลีกย่อยของงาน ระบบต่างๆเรามาเน้นที่สิ่งที่ง่ายที่สุดและเป็นมิตรที่สุดกันดีกว่า ในความเห็นที่ต่ำต้อยของฉัน ระบบดังกล่าวที่แปลกพอสมควรคือ Mercurial - “ระบบควบคุมเวอร์ชันแบบกระจายข้ามแพลตฟอร์มที่ออกแบบมาสำหรับ งานที่มีประสิทธิภาพพร้อมที่เก็บโค้ดขนาดใหญ่มาก" ด้วยเชลล์กราฟิก TortoiseHg ระบบสามารถใช้งานได้บน Windows, Linux และ Mac OS X
ขอจองด่วนครับว่าผมจะอธิบายการทำงานกับระบบใน Windows ครับ สำหรับผู้ที่เชี่ยวชาญ Linux การเรียนรู้ทุกสิ่งด้วยการเปรียบเทียบไม่ใช่เรื่องยาก
นอกจากนี้ในขณะเดียวกันเราก็จะได้เรียนรู้การทำงานด้วย โฮสติ้งฟรีที่เก็บ Mercurial - bitbucket.org จำเป็นหากคุณไม่ได้ทำงานในโปรเจ็กต์เพียงอย่างเดียว หรือซึ่งสะดวกมาก คุณต้องการเข้าถึงโปรเจ็กต์ทุกเวอร์ชันผ่านทางอินเทอร์เน็ต โดยพื้นฐานแล้ว มันเป็นการเปลี่ยนดรอปบ็อกซ์ที่สะดวกหากคุณเคยใช้มาก่อน
ขั้นแรก ติดตั้ง Mercurial + TortoiseHg จากที่นี่: tortoisehg.bitbucket.org
ระบบนี้ทำงานในคอนโซล ดังนั้นเพื่อความสะดวกในการใช้งานเราจะเขียน * เล็กน้อย ไฟล์ค้างคาว ov สำหรับการปฏิบัติการทั่วไป
การดำเนินการทั้งหมดดำเนินการโดยคำสั่ง hg เมื่อเรียกโดยไม่มีพารามิเตอร์ จะแสดงรายการคำสั่งพื้นฐาน
พื้นที่เก็บข้อมูลคือไดเรกทอรีใดๆ ที่เราเลือก (ฉันจะใช้โฟลเดอร์ “C:\project\”) ซึ่งควรจัดเก็บไฟล์ทั้งหมดของโครงการในอนาคตของเรา แน่นอนว่าไม่มีใครห้ามไม่ให้มีที่เก็บข้อมูลหลายอันในคอมพิวเตอร์เครื่องเดียว
เพื่อให้ระบบ “เข้าใจ” ว่าเราต้องการสร้าง repository ให้รันคำสั่ง:
hg เริ่มต้น c:\project
หลังจากนั้นโฟลเดอร์ “c:\project\” จะถูกสร้างขึ้น หากยังไม่ได้สร้างไว้ก่อนหน้านี้ และโฟลเดอร์ “c:\project\.hg\” ซึ่ง Mercurial จะจัดเก็บข้อมูลการบริการทั้งหมด
เราจำได้ทันทีว่าเราต้องการไม่เพียงแต่พื้นที่เก็บข้อมูลในเครื่องบนคอมพิวเตอร์ของเราเท่านั้น แต่ยังต้องการพื้นที่เก็บข้อมูลระยะไกลซึ่งเราจะส่งการเปลี่ยนแปลงทั้งหมดของเราไป (หรืออย่างที่คนฉลาดพูดว่า "พุช" การเปลี่ยนแปลงไปยังพื้นที่เก็บข้อมูลระยะไกล จาก อังกฤษ “ผลักดัน”). ในการดำเนินการนี้ ให้ไปที่ bitbucket.org ลงทะเบียน และสร้างพื้นที่เก็บข้อมูลแรกของคุณ (พื้นที่เก็บข้อมูล - สร้างพื้นที่เก็บข้อมูลใหม่) ตั้งชื่อพื้นที่เก็บข้อมูล (ฉันจะเรียกมันว่า remote_project เพื่อให้เจาะจง) และคลิกสร้างพื้นที่เก็บข้อมูล
ตอนนี้เรามีที่เก็บข้อมูลสองแห่ง - แห่งหนึ่งในเครื่องซึ่งอยู่ในโฟลเดอร์ “c:\project\” และอีกแห่งระยะไกลอยู่ที่ “bitbucket.org/your_account_name/remote_project/” โดยที่ your_account_name เป็นชื่อที่ระบุเมื่อลงทะเบียนบน bitbucket remote_project คือชื่อของที่เก็บ ซึ่งเลือกไว้เมื่อสร้าง
เพื่อที่จะสำรวจต่อไป เราต้องผลักดันบางสิ่งเข้าไปในพื้นที่เก็บข้อมูลในเครื่องของเรา เพียงสร้างมันขึ้นมา (ในกรณีของฉัน ในโฟลเดอร์ “c:\project\”) ไฟล์ใดๆ ของโปรเจ็กต์ในอนาคตของคุณ หรือคัดลอกโปรเจ็กต์ปัจจุบันของคุณที่นั่น
ตอนนี้พูดอย่างเคร่งครัด เราต้องบอก Mercurial: "เราได้เพิ่มไฟล์ดังกล่าวและโฟลเดอร์ใหม่สองสามโฟลเดอร์ลงในโฟลเดอร์โปรเจ็กต์" คำสั่ง "hg add" มีไว้สำหรับสิ่งนี้ อย่างไรก็ตาม มีอีกวิธีหนึ่งที่สะดวกกว่า - ในคอมมิตครั้งถัดไป เราจะบอก Mercurial ให้รับไฟล์ที่สร้างขึ้นใหม่ทั้งหมดจากโฟลเดอร์โปรเจ็กต์และลืมไฟล์ที่ถูกลบทิ้งไป ซึ่งง่ายกว่าการทำ “hg add c:\project\new_document มาก .doc” ทุกครั้งที่คุณสร้างเอกสารใหม่”
เอาล่ะ เรามาต่อกันที่คอมมิตแรกของเรากันดีกว่า มันถูกดำเนินการด้วยคำสั่งต่อไปนี้:
hg กระทำ –A –m “ความคิดเห็นที่จะกระทำ”
ลองดูทุกอย่างตามลำดับ จะต้องป้อนคำสั่งเมื่อเราอยู่ในพื้นที่เก็บข้อมูล (นั่นคือ เราต้องดำเนินการ “cd c:\project”) ก่อน ตัวเลือก “-A” เป็นสิ่งจำเป็นสำหรับ Mercurial ในการ “รับ” ไฟล์ที่สร้างขึ้นใหม่ (ดูด้านบน) ตัวเลือก “-m” ช่วยให้คุณสามารถเพิ่มความคิดเห็นในการคอมมิตได้ ความคิดเห็นเหล่านี้จะแสดงขึ้นเมื่อดูเวอร์ชัน (หรือชุดการแก้ไข - รายการการเปลี่ยนแปลง) ใน TortoiseHg และบนหน้าโครงการใน bitbucket.org เป็นสิ่งสำคัญมากที่จะต้องแสดงความคิดเห็นที่มีความหมายเพื่อไม่ให้ต้องทนทุกข์ทรมานในภายหลังโดยจดจำเมื่อมีการแก้ไขสิ่งนี้หรือครั้งนั้น
ตอนนี้พื้นที่เก็บข้อมูลของเราจะจัดเก็บเวอร์ชันเริ่มต้นของโครงการของเรา การคอมมิตเพิ่มเติมทั้งหมดจะดำเนินการในลักษณะเดียวกันหลังจากที่เราตัดสินใจว่าถึงเวลาบันทึกเวอร์ชันปัจจุบันแล้ว
การคอมมิตที่เสร็จสมบูรณ์สามารถ “พุช” ไปยังพื้นที่เก็บข้อมูลระยะไกลด้วยคำสั่ง:
hg กด https://bitbucket.org/your_account_name/remote_project
ในกรณีนี้ คุณจะต้องอยู่ในโฟลเดอร์ที่เกี่ยวข้องกับพื้นที่เก็บข้อมูลด้วย หลังจากป้อนคำสั่งแล้ว คุณจะถูกถามถึงชื่อและรหัสผ่านของบัญชีของเราบน bitbucket.org เพื่อไม่ให้ป้อนคำสั่งเหล่านี้ในการกดแต่ละครั้ง คำสั่งสามารถถูกแทนที่ด้วยสิ่งต่อไปนี้:
hg กด hg กด https://your_account_name:[email protected]/your_account_name/remote_project
เนื่องจากเราจะเขียนคำสั่งทั้งหมดลงในไฟล์ *.bat ในกรณีนี้รหัสผ่านจะถูกเก็บไว้ แบบฟอร์มเปิดซึ่งเป็นความเสี่ยงด้านความปลอดภัยเล็กน้อย แต่ฉันยอมรับได้
เพื่อความสะดวก เราจึงสร้างไฟล์ commit.bat, push.bat และ commit&push.bat ในพื้นที่การเข้าถึงโดยตรงโดยมีเนื้อหาดังต่อไปนี้:
[เนื้อหาของไฟล์ commit.bat]
ถ้า !%1==! ไปที่ทางออก 1
ซีดี C:\project
hg กระทำ -A -m "%*"
ไปที่ exit0
:ทางออก1
สะท้อน "ไม่มี ARG บรรทัดคำสั่ง!"
:ทางออก0
ไฟล์นี้ ซึ่งถูกเรียกพร้อมอาร์กิวเมนต์ จะคอมมิตโปรเจ็กต์พร้อมกับอาร์กิวเมนต์ที่รวมอยู่ในความคิดเห็นต่อคอมมิต ตัวอย่าง: ดำเนินการ “commit.bat my first commit” และรับการคอมมิตพร้อมความคิดเห็น “my first commit” ใน FAR จะสะดวกในการใช้ชุดค่าผสม Ctrl+Enter สำหรับสิ่งนี้
[เนื้อหาของไฟล์ push.bat]
ซีดี C:\project
hg กด https://your_account_name:[email protected]/your_account_name/remote_project
ไฟล์นี้จะพุชไปยังที่เก็บระยะไกล
[เนื้อหาของไฟล์ commit&push.bat]
ถ้า !%1==! ไปที่ทางออก 1
ซีดี C:\project
hg กระทำ -A -m "%*"
ไปที่ exit0
:ทางออก1
สะท้อน "ไม่มี ARG บรรทัดคำสั่ง!"
:ทางออก0
โทร ./push.bat
ไฟล์นี้ซึ่งถูกเรียกพร้อมอาร์กิวเมนต์ จะดำเนินการตามลำดับการคอมมิตและการพุชของโปรเจ็กต์พร้อมกับอาร์กิวเมนต์ที่ป้อนในความคิดเห็นต่อคอมมิต
นอกจากนี้ สำหรับ Commit ระดับกลางเล็กๆ ฉันแนะนำให้สร้างไฟล์ commit_date_time.bat:
[เนื้อหาของไฟล์ commit_date_time.bat]
ซีดี C:\project
hg กระทำ -A -m "%DATE% %TIME%"
ไฟล์นี้จะคอมมิตด้วยวันที่และเวลาปัจจุบันเป็นความคิดเห็น ซึ่งมักจะสะดวก
ทุกคนตัดสินใจเกี่ยวกับความถี่ในการดำเนินการและผลักดันเป็นรายบุคคล ขึ้นอยู่กับความเข้มข้นและความซับซ้อนของการแก้ไขที่ทำขึ้น แม้จะแนะนำให้ทำตามกฎ “บ่อย ๆ ก็ยิ่งดี”
ด้วยการคลิกขวาที่ไฟล์/โฟลเดอร์ที่เก็บ คุณสามารถเปิด Repository Explorer (TortoiseHg - Repository Explorer) ซึ่งแสดงคอมมิตทั้งหมดของเราพร้อมความคิดเห็น หน้าต่างนี้จะแสดงโครงสร้างแบบแผนผังของพื้นที่เก็บข้อมูลของเรา จากที่นี่ คุณสามารถดำเนินการคอมมิต พุช ย้อนกลับเป็นเวอร์ชันก่อนหน้า (แบ็คเอาท์) และการดำเนินการอื่น ๆ ได้
ที่ bitbucket.org/your_account_name/remote_project มีชุดการแก้ไขที่คล้ายกัน และคุณสามารถดาวน์โหลดโปรเจ็กต์เวอร์ชันใดก็ได้ในไฟล์เก็บถาวรเดียว ซึ่งบางครั้งก็สะดวกมากเช่นกัน
โดยทั่วไป ฉันคิดว่านี่จะเป็นจุดสิ้นสุดของการรู้จัก Mercurial ครั้งแรก สำหรับข้อมูลเพิ่มเติม รายละเอียดข้อมูลสามารถเข้าถึงได้ที่: Translated.by/you/mercurial-the-definitive-guide/into-ru/trans/

บทความนี้เหมาะกับใคร?

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

ป.ล. ย้ายไปที่บล็อก "ระบบควบคุมเวอร์ชัน"

แท็ก: เพิ่มแท็ก

ระบบควบคุมเวอร์ชัน ( ระบบควบคุมเวอร์ชัน VCS) คือซอฟต์แวร์ที่ช่วยให้คุณสามารถติดตามการเปลี่ยนแปลงในเอกสาร ย้อนกลับหากจำเป็น กำหนดว่าใครเป็นผู้แก้ไขและเมื่อใด ฯลฯ บทความนี้กล่าวถึงประเภทต่างๆ วีซีเอสหลักการทำงานตลอดจนตัวอย่าง ผลิตภัณฑ์ซอฟต์แวร์.

ระบบควบคุมเวอร์ชันคืออะไร?

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

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

ระบบควบคุมเวอร์ชันแบบรวมศูนย์และแบบกระจาย

ระบบควบคุมเวอร์ชันสามารถแบ่งออกเป็นสองกลุ่ม: แบบกระจายและแบบรวมศูนย์

ระบบควบคุมเวอร์ชันแบบรวมศูนย์

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

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

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

ระบบควบคุมเวอร์ชันแบบกระจาย

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

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

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

คอมไพล์– ระบบควบคุมเวอร์ชันแบบกระจายที่พัฒนาโดย Linus Torvalds สำหรับการทำงานบนเคอร์เนลของระบบปฏิบัติการ ลินุกซ์- ท่ามกลาง โครงการสำคัญที่ใช้ภายในนั้น คอมไพล์เราสามารถเลือกแกนได้ ลินุกซ์, จำนวน, หุ่นยนต์. คอมไพล์ฟรีและแจกจ่ายภายใต้ใบอนุญาต กนู จีพีแอล 2 และเช่นกัน เมอร์คิวเรียลมีอยู่ในระบบปฏิบัติการเกือบทั้งหมด ตามของพวกเขาเอง ความสามารถพื้นฐาน คอมไพล์คล้ายกับ เมอร์คิวเรียล(และคนอื่น ๆ ดีวีซีเอส) แต่ต้องขอบคุณข้อดีหลายประการ ( ความเร็วสูงงานความสามารถในการบูรณาการกับผู้อื่น วีซีเอส, ส่วนต่อประสานที่ใช้งานง่าย) และชุมชนที่กระตือรือร้นซึ่งก่อตั้งขึ้นรอบระบบนี้ คอมไพล์กลายเป็นผู้นำตลาดในด้านระบบควบคุมเวอร์ชันแบบกระจายควรสังเกตว่าแม้จะได้รับความนิยมอย่างมากจากระบบดังกล่าวเช่น คอมไพล์,บริษัทใหญ่ๆอย่าง Googleให้ใช้ของพวกเขา วีซีเอส.

นี่เป็นการบรรยายเบื้องต้นเกี่ยวกับระบบควบคุมเวอร์ชัน ต่อไปนี้การนำเสนอทั้งหมดจะเกี่ยวข้องเท่านั้น คอมไพล์.

หากคุณต้องการ เรียนรู้จากการบรรยายวิดีโอแล้วเราขอแนะนำหลักสูตรดีๆเกี่ยวกับ คอมไพล์จาก GeekBrains , ไปที่ ลิงค์และค้นหาหลักสูตรในส่วน “หลักสูตร” “คอมไพล์- เริ่มต้นอย่างรวดเร็ว". เขา ฟรีคุณเพียงแค่ต้องลงทะเบียนบนเว็บไซต์ เราขอแนะนำให้คุณพิจารณาแหล่งข้อมูลนี้ให้ละเอียดยิ่งขึ้น มีสิ่งที่น่าสนใจอีกมากมายในนั้น!

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

ระบบควบคุมเวอร์ชัน (cvs), 2017 - เปรียบเทียบ: Git, SVN, Mercurial

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

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

หรือดูวิดีโอจาก GitHub

ระบบควบคุมเวอร์ชันใดที่เหมาะกับโครงการของคุณ?

เราเปรียบเทียบโซลูชันยอดนิยมหลายรายการเพื่อให้คุณเลือกได้ง่ายขึ้น

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

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

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

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

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

ระบบเวอร์ชันพร้อมกัน (ซีวีเอส)

ซีวีเอส ปรากฏในปี 1980 และยังคงได้รับความนิยมในหมู่นักพัฒนาผลิตภัณฑ์เชิงพาณิชย์และนักพัฒนาโอเพ่นซอร์ส

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

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

ตอนนี้ CVS มีการสนับสนุนการทำงานในโครงการที่มีสาขารหัส ซึ่งส่งผลให้มีสินค้าให้เลือกหลายแบบด้วย ลักษณะที่แตกต่างกันซึ่งสามารถนำมารวมกันได้ในภายหลัง

เซิร์ฟเวอร์ CVS มักจะทำงานภายใต้ Unix แต่ซีวีเอส - ลูกค้ายังมีให้บริการในระบบปฏิบัติการยอดนิยมอื่น ๆซีวีเอส - “โตเต็มที่” ผ่านการทดสอบตามเวลาระบบควบคุมเวอร์ชัน- มันยังคงเป็นระบบโอเพ่นซอร์ส แต่ในปัจจุบันมีการเพิ่มคุณสมบัติใหม่ค่อนข้างน้อย

ในเวลาเดียวกัน CVSNT จะเป็นเวอร์ชันที่แยกออกเป็นโปรเจ็กต์ที่แยกจากกันซีวีเอส สำหรับ เซิร์ฟเวอร์วินโดวส์, - ขณะนี้กำลังขยายฟังก์ชันการทำงานค่อนข้างมาก

ข้อดี:

• เทคโนโลยีที่ผ่านการทดสอบตามเวลาซึ่งมีอยู่ในตลาดมานานหลายทศวรรษ

ข้อบกพร่อง:

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

Apache การโค่นล้ม (SVN)

เอสวีเอ็น ถูกสร้างขึ้นมาเป็นทางเลือกซีวีเอส เพื่อแก้ไขข้อบกพร่องซีวีเอส และในขณะเดียวกันก็รับประกันความเข้ากันได้ในระดับสูงด้วย

เช่นเดียวกับ CVS SVN เป็นระบบฟรีการควบคุมเวอร์ชัน โอเพ่นซอร์ส. ข้อแตกต่างเพียงอย่างเดียวคือมีการเผยแพร่ภายใต้ลิขสิทธิ์ Apache ไม่ใช่ภายใต้เปิด ข้อตกลงกนู

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

นักพัฒนาหลายรายได้เปลี่ยนมาใช้SVN เพราะ เทคโนโลยีใหม่ได้รับโอกาสที่ดีกว่าซีวีเอส และในขณะเดียวกันก็ขยายออกไปด้วย

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

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

ข้อดี:

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

ข้อบกพร่อง:

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

คอมไพล์

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

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

Git ยังทำงานบนระบบที่เหมือน Unix (เช่น MacOS) และทำงานต่อไปได้ แพลตฟอร์มวินโดวส์ใช้แพ็คเกจ mSysGit

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

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

ข้อดี:

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

ข้อบกพร่อง:

• อุปสรรคสูงในการเข้า (การเรียนรู้) สำหรับผู้ที่เคยใช้ SVN มาก่อน
• ถูก จำกัด รองรับวินโดวส์(เทียบกับลินุกซ์)

เมอร์คิวเรียล

เมอร์คิวเรียล เปิดตัวพร้อมกับ Git มันเหมือนกันกระจาย ระบบควบคุมเวอร์ชัน.

Mercurial ถูกสร้างขึ้นเป็นทางเลือกแทน Git สำหรับการพัฒนาโมดูลเคอร์เนล Linux แต่เนื่องจากเราเลือก Git Mercurial จึงถูกใช้น้อยลง อย่างไรก็ตาม นักพัฒนาชั้นนำหลายรายก็ทำงานกับระบบนี้ เป็นต้นOpenOffice.org .

ระบบควบคุมเวอร์ชันของ Mercurial แตกต่างจากระบบอื่นระบบควบคุมเวอร์ชันเพราะส่วนใหญ่จะเขียนด้วยภาษา Python (ไม่ใช่ C) อย่างไรก็ตาม บางส่วนถูกนำมาใช้เป็นโมดูลส่วนขยายในภาษาซี

เนื่องจากระบบมีการกระจายอำนาจและเขียนด้วยภาษา Python โปรแกรมเมอร์ Python จำนวนมากจึงมีแนวโน้มที่จะเปลี่ยนมาใช้ Mercurial

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

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

ข้อดี:

• เรียนรู้ง่ายกว่าเมื่อเทียบกับ Git
• เอกสารรายละเอียด
• แบบกระจายระบบควบคุมเวอร์ชัน

ข้อบกพร่อง:

• ไม่มีตัวเลือกในการรวมสาขาหลักสองสาขาเข้าด้วยกัน
• การใช้ปลั๊กอินแทนสคริปต์
• โอกาสน้อยลงสำหรับโซลูชันที่ไม่ได้มาตรฐาน

ที่การควบคุมเวอร์ชันใช้งานได้สำหรับฉัน?

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

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

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

เนื่องจากมีการใช้เทคโนโลยีอย่างแพร่หลายและมีวุฒิภาวะ SVN จึงได้สะสม ฐานขนาดใหญ่ความรู้ทำให้ผู้ใช้ได้รับความช่วยเหลือได้ง่าย

Git เร็วกว่าคู่แข่งอย่างเห็นได้ชัด สำหรับโครงการที่สร้างขึ้นเพื่อเผยแพร่ระบบควบคุมเวอร์ชันนี่คือการปรับปรุงอย่างเห็นได้ชัด

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

สำหรับผู้ที่เกลียด Git (และมีผู้ว่าในหมู่นักพัฒนา) Mercurial ถือเป็นการประนีประนอมระหว่าง SVN และ Git ระบบนี้ใช้ในโครงการที่มีชื่อเสียงมากมายและยังมีเอกสารประกอบที่ดีอีกด้วย

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

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

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

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

หากคุณอยู่ตรงทางแยกหรือเพียงไม่ชอบวิธีการทำงานของ SVN หรือ Git Mercurial คือคำตอบสำหรับคุณ

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

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

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

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

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

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

SVN & GIT โฮสติ้ง

การสร้างที่เก็บข้อมูลแรก

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

• เข้าสู่ระบบบัญชีของคุณ คลิกที่โครงการของคุณ
• การสร้างโครงการ:

• ในบรรทัด "สร้างโครงการใหม่" ให้ป้อนชื่อโครงการของคุณ
• คลิกที่ปุ่ม "สร้างโครงการ"

• การเชื่อมต่อ SVN:

• หลังจากสร้างโครงการแล้ว ให้เลือกแท็บ “การควบคุมแหล่งที่มา” (เวอร์ชันซอร์สโค้ด)
• คลิกที่ลิงค์ “เปิดใช้งานการควบคุมแหล่งที่มา”
• ตั้งชื่อที่เก็บ
• คลิก "บันทึก"

ไคลเอนต์กราฟิก SVN และ GIT

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

— โปรแกรมที่สะดวกที่จะทำงานร่วมกับระบบควบคุมเวอร์ชันบน Microsoft Windows และอาจเป็นไคลเอนต์ Apache Subversion ที่ดีที่สุดที่มีอยู่ TortoiseSVN ถูกนำไปใช้เป็นส่วนขยาย เปลือกหน้าต่างทำให้ง่ายต่อการรวมเข้ากับเบราว์เซอร์ นอกจากนี้ยังเป็นโปรแกรมโอเพ่นซอร์สที่มีชุดภาษา 34 ชุด

SmartGit

– Git ไคลเอนต์กราฟิก ( โอเพ่นซอร์สกระจายระบบควบคุมเวอร์ชัน- ทำงานบน Windows, Mac OS X และ Linuxค่าลิขสิทธิ์ - $39

"กำลังตรวจสอบ" พื้นที่เก็บข้อมูล ("เช็คเอาท์")

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

URL มักจะมีลักษณะดังนี้:https://svn .hostname.com/svn/ > (คุณสามารถใช้ https:// (SSL) ได้ ถ้าคุณมี บัญชีที่ชำระเงิน)

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

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

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

RCS (ระบบควบคุมการแก้ไข) ได้รับการพัฒนาในช่วงต้นทศวรรษ 1980 โดย Walter F. Tichy ระบบอนุญาตให้คุณจัดเก็บเวอร์ชันของไฟล์เดียวเท่านั้น ดังนั้นคุณจึงต้องจัดการหลายไฟล์ด้วยตนเอง สำหรับแต่ละไฟล์ภายใต้การควบคุมของระบบ ข้อมูลเวอร์ชันจะถูกจัดเก็บไว้ในไฟล์พิเศษโดยมีชื่อของไฟล์ต้นฉบับซึ่งมีการเพิ่มอักขระ ",v" ต่อท้าย ตัวอย่างเช่น สำหรับไฟล์ file.txt เวอร์ชันต่างๆ จะถูกจัดเก็บไว้ในไฟล์ file.txt,v ในการจัดเก็บเวอร์ชัน ระบบจะใช้ยูทิลิตี้ diff กล่าวคือ จะจัดเก็บเฉพาะการเปลี่ยนแปลงระหว่างเวอร์ชันเท่านั้น

ลองดูตัวอย่างเซสชันที่มี RCS (เครื่องหมาย $ ต่อไปนี้จะหมายถึงพรอมต์ของระบบปฏิบัติการ) เมื่อเราต้องการวางไฟล์ภายใต้การควบคุม RCS เราใช้คำสั่ง ci (จากการเช็คอิน, การลงทะเบียน):

ไฟล์ $ci.txt

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

$ co file.txt

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

ไฟล์ $ci.txt

เมื่อเรารันคำสั่งนี้ ระบบจะถามเราถึงคำอธิบายการเปลี่ยนแปลง จากนั้นจึงบันทึกไฟล์เวอร์ชันใหม่

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

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

ซีวีเอส

CVS (Concurrent Versions System) ยังคงเป็นระบบที่ใช้กันอย่างแพร่หลาย แต่ก็สูญเสียความนิยมอย่างรวดเร็วเนื่องจากข้อบกพร่องที่ฉันจะกล่าวถึงด้านล่างนี้ Dick Grune พัฒนา CVS ในช่วงกลางทศวรรษ 1980 ในการจัดเก็บแต่ละไฟล์ CVS (เช่นเดียวกับ RCS) จะใช้ไฟล์ในรูปแบบ RCS แต่อนุญาตให้คุณจัดการกลุ่มของไฟล์ที่อยู่ในไดเร็กทอรี CVS ยังใช้สถาปัตยกรรมไคลเอนต์-เซิร์ฟเวอร์ซึ่งข้อมูลเวอร์ชันทั้งหมดถูกเก็บไว้บนเซิร์ฟเวอร์ การใช้สถาปัตยกรรมไคลเอ็นต์-เซิร์ฟเวอร์ทำให้ CVS สามารถใช้งานได้แม้โดยทีมผู้ใช้ที่กระจายตามพื้นที่ทางภูมิศาสตร์ โดยที่ผู้ใช้แต่ละคนมีไดเร็กทอรีการทำงานของตนเองพร้อมสำเนาของโปรเจ็กต์

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

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

ลองดูตัวอย่างเล็กๆ น้อยๆ ของเซสชันกับ CVS ก่อนอื่น คุณต้องนำเข้าโปรเจ็กต์ไปยัง CVS ซึ่งทำได้โดยใช้คำสั่งนำเข้า:

$ cd บางโครงการ $ cvs นำเข้า -m "โครงการใหม่" เส้นทางในที่เก็บไม่มีการเริ่ม

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

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

$ cd some-working-dir $ cvs เส้นทางการชำระเงินในที่เก็บ

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

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

$ cvs กระทำ -m "การเปลี่ยนแปลงบางอย่าง"

เช่นเดียวกับคำสั่งนำเข้า เราระบุความคิดเห็นสำหรับการเปลี่ยนแปลงของเราโดยใช้ตัวเลือก -m

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

อัพเดต $cvs

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

• เนื่องจากเวอร์ชันต่างๆ ถูกจัดเก็บไว้ในไฟล์ RCS จึงไม่สามารถบันทึกเวอร์ชันไดเร็กทอรีได้ วิธีการมาตรฐานเพื่อหลีกเลี่ยงอุปสรรคนี้คือการบันทึกไฟล์บางไฟล์ (เช่น README.txt) ลงในไดเร็กทอรี
• การย้ายหรือเปลี่ยนชื่อไฟล์ไม่อยู่ภายใต้การควบคุมเวอร์ชัน วิธีมาตรฐานในการทำเช่นนี้คือการคัดลอกไฟล์ก่อน ลบไฟล์เก่าโดยใช้คำสั่ง cvs Remove จากนั้นเพิ่มด้วยชื่อใหม่โดยใช้คำสั่ง cvs add

การโค่นล้ม

Subversion (SVN) ได้รับการพัฒนาในปี 2000 ตามความคิดริเริ่มของ CollabNet เดิมที SVN ได้รับการพัฒนาให้เป็น "CVS ที่ดีกว่า" และเป้าหมายหลักของนักพัฒนาคือการแก้ไขข้อผิดพลาดที่เกิดขึ้นในการออกแบบ CVS ในขณะที่ยังคงรักษาอินเทอร์เฟซที่คล้ายกันไว้ SVN เช่นเดียวกับ CVS ใช้สถาปัตยกรรมไคลเอ็นต์-เซิร์ฟเวอร์ การเปลี่ยนแปลงที่สำคัญที่สุดเมื่อเปรียบเทียบกับ CVS ได้แก่:

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

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

$ cd บางโครงการ $ svn นำเข้า -m เส้นทาง "โครงการใหม่" ในที่เก็บ

ต่างจาก CVS ตรงที่ไม่จำเป็นต้องระบุแท็กนักพัฒนาและโปรเจ็กต์ ซึ่งไม่ค่อยได้ใช้ในทางปฏิบัติ

ตอนนี้เราจำเป็นต้องสร้างสำเนาการทำงานของโครงการโดยใช้คำสั่ง checkout หรือ co :

$ cd some-working-dir $ svn เส้นทางการชำระเงินในที่เก็บ

หลังจากทำการเปลี่ยนแปลง เราใช้คำสั่ง commit หรือ ci เพื่อบันทึกการเปลี่ยนแปลงไปยังที่เก็บ:

$ svn กระทำ -m "การเปลี่ยนแปลงบางอย่าง"

และหากต้องการอัพเดตสำเนาการทำงานของโปรเจ็กต์ ให้ใช้คำสั่ง update หรือ up

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

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

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

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

ระบบควบคุมเวอร์ชันส่วนใหญ่มีคุณสมบัติดังต่อไปนี้:

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

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

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

รอบการทำงานในแต่ละวันวงจรการทำงานของนักพัฒนาทั่วไปในระหว่างวันทำงานมีลักษณะดังนี้:

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