Mercurial และ Git ต่างกันอย่างไร

ฉันใช้ git มาระยะหนึ่งแล้วบน Windows (กับ msysGit) และฉันชอบแนวคิดของการควบคุมแหล่งที่มาแบบกระจาย เมื่อไม่นานมานี้ฉันได้ดู Mercurial (hg) และมันน่าสนใจ อย่างไรก็ตามฉันไม่สามารถคลุมหัวความแตกต่างระหว่าง hg และ git

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

บทความเหล่านี้อาจช่วย:

• Git vs. Mercurial: โปรดผ่อนคลาย (Git คือ MacGyver และ Mercurial คือ James Bond)
• ความแตกต่างระหว่าง Mercurial และ Git

แก้ไข : การเปรียบเทียบ Git และ Mercurial กับคนดังดูเหมือนจะเป็นเทรนด์ นี่คืออีกหนึ่ง:

• Git คือ Wesley Snipes, Mercurial คือ Denzel Washington

ฉันทำงานกับ Mercurial แต่ฉันเชื่อว่าทั้งสองระบบนั้นเท่าเทียมกัน พวกเขาทั้งสองทำงานร่วมกับ abstractions ที่เหมือนกัน: ชุดของสแน็ปช็อต (เซ็ตการแก้ไข) ซึ่งประกอบกันเป็นประวัติศาสตร์ แต่ละเซ็ตการแก้ไขรู้ว่ามันมาจากไหน (เซ็ตการแก้ไขพาเรนต์) และสามารถมีเซ็ตการแก้ไขย่อยจำนวนมากได้ ส่วนขยายhg-gitเมื่อเร็ว ๆ นี้ให้สะพานสองทางระหว่าง Mercurial และ Git และการเรียงลำดับของการแสดงจุดนี้

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

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

ฉันใช้ Linux แต่เห็นได้ชัดว่า TortoiseHg นั้นเร็วกว่าและดีกว่า Git ที่เทียบเท่ากับ Windows (เนื่องจากการใช้ระบบไฟล์ Windows ที่ไม่ดี) ทั้งhttp://github.comและhttp://bitbucket.orgให้บริการโฮสติ้งออนไลน์บริการที่ Bitbucket นั้นยอดเยี่ยมและตอบสนองได้ดี (ฉันยังไม่ได้ลอง gitub)

ฉันเลือก Mercurial เพราะรู้สึกสะอาดและสง่างาม - ฉันถูกนำออกโดยสคริปต์ shell / Perl / Ruby ที่ฉันมีกับ Git ลองมองดูgit-instaweb.shไฟล์ถ้าคุณอยากรู้ว่าฉันหมายถึงอะไร: มันคือเชลล์สคริปต์ที่สร้างสคริปต์Rubyซึ่งฉันคิดว่าใช้งานเว็บเซิร์ฟเวอร์ เชลล์สคริปต์สร้างเชลล์สคริปต์อื่นเพื่อเรียกใช้สคริปต์รูบีแรก นอกจากนี้ยังมีPerlเล็กน้อยสำหรับการวัดที่ดี

ฉันชอบโพสต์บล็อกที่เปรียบเทียบ Mercurial และ Git กับ James Bond และ MacGyver - Mercurial นั้นสำคัญน้อยกว่า Git ดูเหมือนว่าฉันว่าคนที่ใช้ Mercurial ไม่ค่อยประทับใจเท่าไหร่ สิ่งนี้สะท้อนให้เห็นว่าแต่ละระบบทำสิ่งที่ Linus อธิบายว่าเป็น"การผสานที่ยอดเยี่ยมที่สุด" . ใน Git คุณสามารถรวมกับที่เก็บที่ไม่เกี่ยวข้องได้โดยทำดังนี้

git fetch <project-to-union-merge>
GIT_INDEX_FILE=.git/tmp-index git-read-tree FETCH_HEAD
GIT_INDEX_FILE=.git/tmp-index git-checkout-cache -a -u
git-update-cache --add -- (GIT_INDEX_FILE=.git/tmp-index git-ls-files)
cp .git/FETCH_HEAD .git/MERGE_HEAD
git commit

คำสั่งเหล่านั้นดูค่อนข้างที่จะลับตาฉัน ใน Mercurial เราทำ:

hg pull --force <project-to-union-merge>
hg merge
hg commit

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

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

นั่นคือสาระสำคัญของความแตกต่าง

Git นั้นเข้าใจได้ดีที่สุดตั้งแต่แรกเริ่ม - จากรูปแบบของที่เก็บ Git Talk ของ Scott Chaconเป็นไพรเมอร์ที่ยอดเยี่ยมสำหรับเรื่องนี้ หากคุณพยายามใช้คอมไพล์โดยไม่ทราบว่าเกิดอะไรขึ้นภายใต้ประทุนคุณจะสับสนในบางจุด (เว้นแต่คุณจะยึดติดกับฟังก์ชั่นพื้นฐานเท่านั้น) นี่อาจฟังดูงี่เง่าเมื่อคุณต้องการเป็น DVCS สำหรับกิจวัตรประจำวันของคุณ แต่อัจฉริยะของคอมไพล์คือรูปแบบที่เก็บนั้นง่ายมากจริง ๆ และคุณสามารถเข้าใจการทำงานทั้งหมดของ git ได้อย่างง่ายดาย

สำหรับการเปรียบเทียบเชิงเทคนิคเพิ่มเติมบทความที่ดีที่สุดที่ฉันได้เห็นเป็นการส่วนตัวของดัสตินแซลลิงส์:

• ความแตกต่างระหว่าง Mercurial และ Git
• หัวข้อ Reddit ที่ดัสตินที่มีประสบการณ์คอมไพล์ตอบคำถามในคอมไพล์ของคอมไพล์ของเขาเอง

เขาใช้ DVCS ทั้งสองอย่างกว้างขวางและเข้าใจทั้งสองอย่างดีและจบลงด้วยการเลือกคอมไพล์

ความแตกต่างที่สำคัญคือบน Windows Mercurial ได้รับการสนับสนุนอย่างเป็นธรรมชาติไม่ใช่ Git คุณสามารถรับโฮสติ้งที่คล้ายกันมากกับgithub.comด้วยbitbucket.org (จริง ๆ แล้วดียิ่งขึ้นเมื่อคุณได้รับพื้นที่เก็บข้อมูลส่วนตัวฟรี) ฉันใช้ msysGit อยู่พักหนึ่ง แต่ย้ายไปที่ Mercurial และมีความสุขมาก

หากคุณเป็นนักพัฒนา Windows ที่กำลังมองหาการควบคุมการแก้ไขการยกเลิกการเชื่อมต่อแบบพื้นฐานให้ไปที่ Hg ฉันพบว่า Git นั้นเข้าใจยากในขณะที่ Hg นั้นเรียบง่ายและรวมเข้ากับเชลล์ของ Windows ได้เป็นอย่างดี ฉันดาวน์โหลด Hg และติดตามบทช่วยสอนนี้ (hginit.com) - สิบนาทีต่อมาฉันมี repo ในพื้นที่และกลับมาทำงานในโครงการของฉัน

ฉันคิดว่าคำอธิบายที่ดีที่สุดเกี่ยวกับ "Mercurial vs. Git" คือ:

"Git คือ Wesley Snipes Mercurial is Denzel Washington"

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

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

กล่าวโดยย่อแต่ละสาขาใน Mercurial ต้องการไดเรกทอรีของตนเอง ใน git คุณมักจะทำงานในไดเรกทอรีเดียว การสลับสาขาใน Mercurial หมายถึงการเปลี่ยนไดเรกทอรี ใน git, มันหมายถึงการขอให้ git เปลี่ยนเนื้อหาของไดเรกทอรีด้วย git checkout

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

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

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

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

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

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

ในทางปฏิบัติหมายความว่าอย่างไร การดำเนินการหลายอย่างรวดเร็วกว่าในคอมไพล์เช่นการเปลี่ยนไปใช้คอมมิทอื่นการเปรียบเทียบคอมมิท ฯลฯ โดยเฉพาะถ้าคอมมิทเหล่านี้อยู่ไกล

AFAIK ไม่มีข้อได้เปรียบจากวิธีการของ Mercurial

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

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

นอกจากนี้ยังมีการเปรียบเทียบของ google (แม้ว่าจะค่อนข้างเก่าแล้วเสร็จในปี 2008)

http://code.google.com/p/support/wiki/DVCSAnalysis

ถ้าฉันเข้าใจพวกเขาอย่างถูกต้อง (และฉันยังห่างไกลจากผู้เชี่ยวชาญในแต่ละคน) พวกเขาพื้นฐานแต่ละคนมีปรัชญาที่แตกต่างกัน ฉันใช้ Mercurial เป็นครั้งแรกเป็นเวลา 9 เดือน ตอนนี้ฉันใช้คอมไพล์สำหรับ 6

hg เป็นซอฟต์แวร์ควบคุมเวอร์ชัน เป้าหมายหลักคือการติดตามซอฟต์แวร์รุ่นต่างๆ

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

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

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

เท่าที่เกี่ยวข้องกับคอมไพล์ไม่มี "1 โครงการ" คุณสามารถมี 50 โครงการใน repo เดียวกันและคอมไพล์ไม่สนใจ แต่ละคนสามารถจัดการแยกต่างหากใน repo เดียวกันและอยู่ได้ดี

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

ฉันไม่รู้ว่ามันสมเหตุสมผลหรือไม่ ถ้าฉันวาดรูปได้ hg อาจมีลักษณะเช่นนี้ที่แต่ละการกระทำเป็นo

             o---o---o
            /        
o---o---o---o---o---o---o---o
         \         /
          o---o---o

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

o---o---o---o---o

o---o---o---o
         \
          o---o

o---o---o---o

ในความเป็นจริงในบางวิธีมันไม่สมเหตุสมผลที่จะแสดงกิ่งก้านในคอมไพล์

สิ่งหนึ่งที่สับสนมากสำหรับการสนทนาคอมไพล์และ mercurial ทั้งสองมีสิ่งที่เรียกว่า "สาขา" แต่พวกเขาไม่ได้จากระยะไกลสิ่งเดียวกัน สาขา Mercurial เกิดขึ้นเมื่อมีข้อขัดแย้งระหว่าง repos ต่างกัน เห็นได้ชัดว่าสาขาในคอมไพล์คล้ายกับโคลนใน hg แต่การโคลนนิ่งในขณะที่มันอาจให้พฤติกรรมคล้าย ๆ กันนั้นไม่เหมือนกันแน่นอนที่สุด ลองพิจารณาฉันลองใช้ git กับ hg โดยใช้ chromium repo ซึ่งค่อนข้างใหญ่

$ time git checkout -b some-new-branch
Switched to new branch 'some-new-branch'

real   0m1.759s
user   0m1.596s
sys    0m0.144s

และตอนนี้ใช้ hg ด้วยโคลน

$ time hg clone project/ some-clone/

updating to branch default
29387 files updated, 0 files merged, 0 files removed, 0 files unresolved.
real   0m58.196s
user   0m19.901s
sys    0m8.957

ทั้งสองอย่างนั้นร้อนจัด คือฉันวิ่งสองครั้งและนี่เป็นการวิ่งครั้งที่สอง hg clone เป็นจริงเหมือนกับ git-new-workdir ทั้งของผู้ที่ทำให้ dir cp -r project project-cloneทำงานใหม่ทั้งหมดเกือบราวกับว่าคุณได้พิมพ์ มันไม่เหมือนกับการสร้างสาขาใหม่ในคอมไพล์ มันหนักกว่ามาก หากมีความจริงเทียบเท่ากับการแตกแขนงของคอมไพล์เป็น hg ฉันไม่รู้ว่ามันคืออะไร

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

git checkout master
git checkout -b add-2nd-joypad-support
git checkout master
git checkout -b fix-game-save-bug
git checkout master
git checkout -b add-a-star-support

นั่นเพิ่งสร้าง 3 สาขาแต่ละสาขาแยกจากสาขาที่เรียกว่ามาสเตอร์ (ฉันแน่ใจว่ามีวิธีในการคอมไพล์เพื่อให้ 1 บรรทัดเหล่านั้นแทน 2)

ตอนนี้ที่จะทำงานกับคนที่ฉันเพิ่งทำ

git checkout fix-game-save-bug

และเริ่มทำงาน มอบสิ่งต่าง ๆ ฯลฯ สลับไปมาระหว่างสาขาแม้ในโครงการใหญ่เท่าโครเมี่ยมเกือบจะทันที จริง ๆ แล้วฉันไม่รู้ว่าจะทำยังไงใน hg มันไม่ได้เป็นส่วนหนึ่งของบทเรียนใด ๆ ที่ฉันได้อ่าน

อีกหนึ่งความแตกต่างที่ยิ่งใหญ่ เวทีของ Git

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

แล้วจุดของเวทีคืออะไร? คุณสามารถแยกการกระทำของคุณได้อย่างง่ายดาย จินตนาการว่าคุณได้แก้ไข joypad.cpp และ gamesave.cpp และคุณต้องการแยกมันออกจากกัน

git add joypad.cpp  // copies to stage
git commit -m "added 2nd joypad support"
git add gamesave.cpp  // copies to stage
git commit -m "fixed game save bug"

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

มีแผนภูมิเปรียบเทียบแบบไดนามิกอยู่ที่ versioncontrolblog ซึ่งคุณสามารถเปรียบเทียบระบบควบคุมรุ่นต่าง ๆ ได้หลายแบบ

นี่คือตารางเปรียบเทียบระหว่าง git, hg และ bzr

มีความแตกต่างอย่างมากเมื่อทำงานกับสาขา (โดยเฉพาะในระยะสั้น)

มีการอธิบายไว้ในบทความนี้ (BranchingExplained)ซึ่งเปรียบเทียบ Mercurial กับ Git

มีผู้ทำงานร่วมกันบน Windows ในโครงการของคุณหรือไม่

เพราะถ้ามี GUI Git-for-Windows นั้นดูงุ่มง่ามยากลำบากและไม่เป็นมิตร

ในทางตรงกันข้าม Mercurial-on-Windows นั้นเป็นเกมง่ายๆ

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

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

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

ขณะนี้ฉันอยู่ในขั้นตอนการย้ายจาก SVN ไปยัง DVCS (ในขณะที่เขียนบล็อกเกี่ยวกับสิ่งที่ฉันค้นพบ, ความพยายามในการเขียนบล็อกครั้งแรกของฉัน ... ) และฉันได้ทำการวิจัยเล็กน้อย (= googling) เท่าที่ฉันเห็นคุณสามารถทำสิ่งต่าง ๆ ส่วนใหญ่กับแพคเกจทั้งสอง ดูเหมือนว่าคอมไพล์มีคุณสมบัติขั้นสูงที่นำมาใช้ไม่กี่อย่างหรือดีกว่าฉันรู้สึกว่าการรวมกับ windows นั้นค่อนข้างดีกว่าสำหรับ Mercurial ด้วย TortoiseHg ฉันรู้ว่ามีเสือชีตาห์ Git เช่นกัน (ฉันลองทั้งคู่) แต่วิธีแก้ปัญหา Mercurial นั้นแข็งแกร่งขึ้น

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

ฉันคิดว่าสำหรับแนวทางปฏิบัติทั่วไป Git และ Mercurial นั้นมากเกินพอ พวกเขาทั้งสองมีโครงการขนาดใหญ่ที่ใช้พวกเขา (Git -> เคอร์เนลลินุกซ์, Mercurial -> โครงการ Mozilla พื้นฐานทั้งสองอย่างนี้) ดังนั้นฉันไม่คิดว่าจะขาดอะไรบางอย่างจริงๆ

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

มีดีและละเอียดถี่ถ้วนตารางเปรียบเทียบและการชาร์ตบนคอมไพล์ Mercurial และบาซาร์มากกว่าที่เป็นคู่มือ InfoQ เกี่ยวกับ DVCS

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

ทั้ง Eclipse (และทุกอย่างขึ้นอยู่กับมัน) และ NetBeans บางครั้งมีปัญหาเกี่ยวกับระบบไฟล์ระยะไกล (เช่น SSH) และการอัพเดตไฟล์ภายนอก ซึ่งเป็นอีกสาเหตุหนึ่งที่ทำให้คุณต้องการทำงานที่ "ไร้รอยต่อ"

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

อีกหนึ่งการเปรียบเทียบที่น่าสนใจของปรอทและคอมไพล์: Mercurial VS Git จุดสนใจหลักคือเรื่องภายในและอิทธิพลที่มีต่อกระบวนการแยกสาขา

หากคุณมีความสนใจในการเปรียบเทียบประสิทธิภาพการทำงานของ Mercurial และ Git มีลักษณะที่เกี่ยวข้องในบทความนี้ บทสรุปคือ:

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

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

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

ลิงค์นี้อาจช่วยให้คุณเข้าใจความแตกต่าง http://www.techtatva.com/2010/09/git-mercurial-and-bazaar-a-comparison/

บางคนคิดว่าระบบ VCS ต้องมีความซับซ้อน พวกเขาสนับสนุนการประดิษฐ์คำศัพท์และแนวคิดในสนาม พวกเขาอาจจะคิดว่าปริญญาเอกจำนวนมากในเรื่องจะน่าสนใจ ในบรรดาคนเหล่านั้นอาจเป็นคนที่ออกแบบ Git

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

เครื่องมือระดับมืออาชีพใด ๆ จะต้องมาพร้อมกับ CLI ที่ออกแบบมาอย่างชัดเจนและใช้งานง่าย ผู้ใช้ Mercurial สามารถทำงานส่วนใหญ่ได้ด้วยการออกคำสั่งง่ายๆโดยไม่มีตัวเลือกแปลก ๆ ใน Git double dash ตัวเลือกที่บ้าเป็นบรรทัดฐาน Mercurial มีข้อได้เปรียบที่สำคัญหากคุณเป็นบุคคล CLI (และด้วยความซื่อสัตย์ควรมีวิศวกรซอฟต์แวร์ที่เคารพตนเอง)

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

$ hg rollback

จากนั้นคุณจะได้รับข้อความว่าระบบยกเลิกการทำธุรกรรมครั้งสุดท้ายของคุณ

ใน Git คุณต้องพิมพ์:

$ git reset --soft HEAD^

โอเคสมมติว่าคุณมีความคิดว่าการรีเซ็ตนั้นเกี่ยวกับอะไร แต่นอกจากนี้คุณต้องรู้ว่าการรีเซ็ต "--soft" และ "--hard" คืออะไร (เดาได้ง่ายหรือไม่?) โอ้และแน่นอนอย่าลืมตัวละคร '^' ในที่สุด! (ตอนนี้ชื่อริชชี่คืออะไร ... )

การผสานรวมของ Mercurial กับเครื่องมือของบุคคลที่สามเช่น kdiff3 และ meld นั้นดีกว่าเช่นกัน สร้างแพทช์ของคุณผสานสาขาของคุณโดยไม่ต้องยุ่งยากมาก Mercurial ยังมีเซิร์ฟเวอร์ http ธรรมดาที่คุณเปิดใช้งานโดยการพิมพ์

hg serve

และให้คนอื่นดูที่เก็บของคุณ

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