อะไรคือความแตกต่างระหว่าง 'git pull' และ 'git fetch'?


11914

อะไรคือความแตกต่างระหว่างgit pullและgit fetch?


364
ฉันพบบทความที่เขียนเป็นอย่างดีเกี่ยวกับการเรียก git และ git pull มันคุ้มค่ากับการอ่าน: longair.net/blog/2009/04/16/git-fetch-and-merge
Marcos Oliveira

51
แนวทางทางเลือกของเราได้กลายgit fetch; git reset --hard origin/masterเป็นส่วนหนึ่งของกระบวนการทำงานของเรา มันทำให้การเปลี่ยนแปลงในพื้นที่ทำให้คุณรู้ทันกับ Master BUT แต่ทำให้แน่ใจได้ว่าคุณจะไม่ดึงการเปลี่ยนแปลงใหม่ที่อยู่ด้านบนของการเปลี่ยนแปลงปัจจุบันและทำให้เกิดความยุ่งเหยิง เราใช้มันมาระยะหนึ่งแล้วและโดยพื้นฐานแล้วมันให้ความรู้สึกปลอดภัยมากกว่าในการฝึกฝน เพียงให้แน่ใจว่าได้เพิ่ม / ส่ง / ซ่อนการทำงานใด ๆ ในความคืบหน้าก่อน!
Michael Durrant

26
ตรวจสอบให้แน่ใจว่าคุณรู้วิธีใช้ที่เก็บ git อย่างถูกต้อง หากคุณกำลังถามเกี่ยวกับ 'ดึง' และ 'ดึงข้อมูล' ดังนั้นบางที 'ที่เก็บข้อมูล' ก็จำเป็นต้องอธิบาย ...
Henry Heleine

36
ผู้คนจำนวนมากที่มาจาก Mercurial ใช้ "git pull" โดยคิดว่ามันเทียบเท่ากับ "hg pull" ซึ่งมันไม่ใช่ Git ที่เทียบเท่ากับ "hg pull" คือ "git fetch"
Serge Shultz

8
คำสั่ง git fetch กำลังดึงรหัสที่อัปเดตพร้อมกับสาขาและจะได้รับการเพิ่มสาขาใหม่ในพื้นที่ของคุณคำสั่ง git pull จะดึงเฉพาะรหัสที่อัปเดตของสาขาปัจจุบันเท่านั้น
Kartik Patel

คำตอบ:


9916

ในแง่ที่ง่ายที่สุดgit pullที่ไม่ตามมาด้วยgit fetchgit merge

คุณสามารถทำgit fetchในเวลาใด ๆ refs/remotes/<remote>/ในการปรับปรุงสาขาระยะไกลการติดตามของคุณภายใต้

การดำเนินการนี้จะไม่เปลี่ยนแปลงสาขาในพื้นที่ของคุณrefs/headsและจะปลอดภัยโดยไม่ต้องเปลี่ยนสำเนาการทำงานของคุณ ฉันเคยได้ยินแม้แต่คนที่ทำงานgit fetchเป็นระยะในงาน cron ในพื้นหลัง (แม้ว่าฉันจะไม่แนะนำให้ทำเช่นนี้)

A git pullคือสิ่งที่คุณต้องทำเพื่อให้สาขาในประเทศเป็นเวอร์ชันล่าสุดด้วยรีโมตในขณะที่อัพเดตสาขาการติดตามรีโมตอื่น ๆ ของคุณ

เอกสาร Git - git pull :

ในโหมดเริ่มต้นของgit pullคือชวเลขตามมาด้วยgit fetchgit merge FETCH_HEAD


326
"A" git pull "เป็นสิ่งที่คุณต้องทำเพื่อทำให้ที่เก็บข้อมูลของคุณทันสมัย" <- การอัปเดตที่เก็บข้อมูลไม่ได้ดำเนินการโดยดึงข้อมูลมาใช่หรือไม่ คุณไม่ได้หมายความว่าจะทำให้สาขาท้องถิ่นของคุณทันสมัยด้วยสาขาระยะไกลหรือไม่ ถึงการรวม: มันรวมสาขาที่อยู่ห่างไกลเข้ากับสำเนาสาขาในประเทศของคุณหรือจะรวมกันที่นี่?
อัลเบิร์ต

194
@Albert: ใช่มันเป็นคำพูดที่แปลก git pullจะรวมเข้ากับสาขาปัจจุบันเสมอ เพื่อให้คุณเลือกสาขาที่คุณต้องการที่จะดึงจากและจะดึงมันลงไปในสาขาปัจจุบัน จากสาขาสามารถเป็นท้องถิ่นหรือระยะไกล; มันอาจเป็นสาขาระยะไกลที่ไม่ได้ลงทะเบียนgit remote(หมายถึงคุณผ่าน URL ในgit pullบรรทัดคำสั่ง)
intuited

129
@ espertus: ไม่การกดปุ่มจะไม่ทำการผสานโดยอัตโนมัติ ผู้ใช้คาดว่าจะดึงแก้ไขข้อขัดแย้งในการผสานใด ๆ ในเครื่องจากนั้นดันกลับไปที่รีโมท
Greg Hewgill

33
หากฉันอยู่ที่/home/alice/และทำgit fetch /home/bobสิ่งที่ฉันควรจะส่งผ่านพารามิเตอร์ต่อไปgit merge?
ripper234

106
หมายเหตุสำหรับคนที่เรียน Git: pullไม่สามารถเอาอย่าง a fetchบวกmergeได้ ฉันเพิ่งเรียกการเปลี่ยนแปลงเมื่อมีการเปลี่ยนแปลงตัวชี้สาขาระยะไกลเท่านั้นและmergeปฏิเสธที่จะทำอะไร pullในทางตรงข้ามสาขาการติดตามของฉันอย่างรวดเร็ว
Roman Starkov

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

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


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

126
@elexhobby แบบสั้นgit fetchเฉพาะอัปเดต.git/ไดเรกทอรีของคุณ(AKA: ที่เก็บในเครื่อง) และไม่มีอะไรนอก.git/(AKA: แผนผังการทำงาน) มันไม่ได้เปลี่ยนสาขาในประเทศของคุณและมันก็ไม่ได้สัมผัสmasterเช่นกัน มันสัมผัสremotes/origin/masterแม้ว่า (ดูgit branch -avv) git remote updateถ้าคุณมีรีโมทมากขึ้นลอง นี่คือgit fetchสำหรับรีโมททั้งหมดในคำสั่งเดียว
Tino

24
@Tino ของคุณเป็นจุดสำคัญที่สุดจริงๆ คนอาจจะไม่ทราบว่า "ไกล" สาขาจะถูกเก็บไว้เป็นจริงพวงของ hashes .git/refs/remotes/origin/ใน
Chris

13
เมื่อคุณดึง Git รวบรวมคอมมิชชันใด ๆ จากสาขาเป้าหมายที่ไม่มีอยู่ในสาขาปัจจุบันของคุณและเก็บไว้ในพื้นที่เก็บข้อมูลในพื้นที่ของคุณ - ฉันจะดูสิ่งที่นำมาจากระยะไกลและฉันจะรวมมันเข้าไปในสาขาท้องถิ่นของฉันได้อย่างไร?
アレックス

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

1210

มันเป็นสิ่งสำคัญที่จะแตกต่างปรัชญาการออกแบบของ git กับปรัชญาของเครื่องมือควบคุมแหล่งแบบดั้งเดิมเช่น SVN

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

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

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

  • git fetch เป็นคำสั่งที่ระบุว่า "ทำให้สำเนาที่เก็บในพื้นที่ห่างไกลของฉันเป็นปัจจุบัน"

  • git pull กล่าวว่า "นำการเปลี่ยนแปลงในที่เก็บระยะไกลไปยังที่ที่ฉันเก็บรหัสของตัวเอง"

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

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


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

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

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

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

5
@ Nabheet Thing คือ Git นั้นมุ่งเน้นเนื้อหา มันเก็บข้อมูลเพียงครั้งเดียวและชี้ไปที่มันหลายครั้ง นั่นเป็นสาเหตุที่ Git ถึงแม้จะทำหลายอย่างบนต้นฉบับไม่ส่งผลกระทบต่อขนาดของ repo มากนักเนื่องจากวัตถุส่วนใหญ่เหมือนกัน
cst1992

888

นี่คือภาพลักษณ์ของโอลิเวอร์สตีลว่าทุกอย่างลงตัวกันอย่างไร :

ป้อนคำอธิบายรูปภาพที่นี่

หากมีความสนใจเพียงพอฉันคิดว่าฉันสามารถอัปเดตภาพเพื่อเพิ่มgit cloneและgit merge...


156
ภาพที่อัปเดตด้วยgit cloneและgit mergeจะมีประโยชน์มาก!
MEMark

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

12
ภาพที่มีค่าพันคำ! รูปภาพที่อัปเดตพร้อมด้วยการโคลนและผสานการไหลของข้อมูลพร้อมอยู่ที่ไหนสักแห่งหรือไม่ มีการไหลของข้อมูลอื่นนอกเหนือจากที่มีอยู่ในแผนภาพหรือไม่?
shikhanshu

10
@Contango โปรดเพิ่มโคลนและผสาน จะเป็นประโยชน์สำหรับมือใหม่อย่างฉัน
ค่าเช่า

11
มีไดอะแกรมสองรูปที่แสดงการโคลนและผสานในคำตอบอื่น ๆ (ด้านล่าง) โดย th3sly และ thedarkpassenger
intotecho

488

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

git fetch
git diff ...origin

ดู: https://git-scm.com/docs/git-diffเกี่ยวกับไวยากรณ์สองและสามจุดในคำสั่ง diff


9
ทำไมไม่git diff ..origin?
Erik Kaplun

3
git diff origin และ git diff .. ผู้เริ่มต้นดูเหมือนจะทำงาน แต่ไม่ใช่สิ่งที่แปลก ... stuff
Marc

19
@Compustretch ไม่ควรมีช่องว่าง git diff ...originเทียบเท่ากับgit diff $(git-merge-base HEAD origin) origin(ดูในgit diff [--options] <commit>...<commit> [--] [<path>…]ส่วนของkernel.org/pub/software/scm/git/docs/git-diff.html#_description ) ซึ่งแตกต่างจากgit diff origin; git diff ...originเป็นแนวคิดการเปลี่ยนแปลงที่เกิดขึ้นในoriginตั้งแต่สาขาปัจจุบันแยกจากoriginในขณะที่ยังรวมถึงการย้อนกลับของการเปลี่ยนแปลงที่เกิดขึ้นในสาขาปัจจุบันเพราะมันแยกจากgit diff origin origin
Max Nanasy

2
ไม่มีคำสั่ง .. ใช้งานได้สำหรับฉัน (บน Windows) แต่git diff origin/masterทำงานตามที่ระบุไว้ด้านล่าง
Brian Burns

เหมือนกันที่นี่โดยใช้ git 2.0.0 บน OSX คำสั่งเหล่านี้ไม่ทำงาน พวกเขาเลิกใช้แล้วหรือยัง?
K. -Michael Aye

373

ฉันเสียค่าใช้จ่ายเล็กน้อยที่จะเข้าใจว่าอะไรคือความแตกต่าง แต่นี่เป็นคำอธิบายง่ายๆ masterใน localhost ของคุณเป็นสาขา

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

เมื่อคุณเริ่มทำงานและทำคุณมุ่งหน้าตัวชี้หลักไปที่HEAD+ การกระทำของคุณ แต่ตัวชี้กำเนิด / ต้นแบบยังคงชี้ไปที่มันเมื่อคุณโคลน

ดังนั้นความแตกต่างจะเป็น:

  • ถ้าคุณทำgit fetchมันก็จะดึงข้อมูลการเปลี่ยนแปลงทั้งหมดในที่เก็บระยะไกล ( GitHub ) และย้ายตัวชี้แหล่งกำเนิด / HEADหลักไปยัง ในขณะที่นายสาขาในพื้นที่ของคุณจะชี้ไปที่ที่นั่น
  • ถ้าคุณทำgit pullมันจะไม่สามารถดึงข้อมูลโดยทั่วไป (ตามที่อธิบายไว้ก่อนหน้านี้) และผสานการเปลี่ยนแปลงใหม่ ๆ HEADไปยังสาขาหลักของคุณและย้ายตัวชี้ไปยัง

14
Origin / master เป็นสาขาในประเทศที่เป็น COPY ของ master บน origin เมื่อคุณดึงข้อมูลคุณอัปเดตในท้องถิ่น: / origin / master เมื่อคุณคร่ำครวญว่าทุกอย่างใน git นั้นเป็นสาขาสิ่งนี้สมเหตุสมผลและเป็นวิธีที่ทรงพลังมากในการรักษาเซ็ตการเปลี่ยนแปลงต่าง ๆ สร้างกิ่งก้านสาขาในท้องถิ่นได้อย่างรวดเร็วผสานและทำการรีบูตและโดยทั่วไปจะได้รับคุณค่ามากมาย แบบ
cam8001

3
ยังคงสับสน ฉันคิดว่าgit fetchการดาวน์โหลดการเปลี่ยนแปลงใน repo ระยะไกลเป็น repo ในพื้นที่ของคุณ แต่ไม่ยอมรับพวกเขา - กล่าวคือพวกเขายังคงต้องเพิ่ม / มุ่งมั่นที่ repo ในพื้นที่ของคุณ
krb686

3
ดึงเฉพาะดึงจากระยะไกล / กำเนิด (GitHub) เพื่อกำเนิดท้องถิ่นของคุณ แต่จะไม่รวมเข้ากับไฟล์ทำงานจริงของคุณ หากคุณดึงมันจะดึงข้อมูลและรวมเข้ากับไฟล์การทำงานปัจจุบันของคุณ
Gerardo

223

บางครั้งการแสดงภาพช่วย

ป้อนคำอธิบายรูปภาพที่นี่


18
ฉันคิดว่าภาพจะต้องแสดงให้เห็นว่ามันส่งผลกระทบต่อ repo ท้องถิ่นด้วย นั่นคือ Git pull คือการรวมกันของ repo ท้องถิ่นและสำเนาการทำงาน ตอนนี้ดูเหมือนว่ามันจะส่งผลกระทบต่อสำเนาการทำงาน
nonopolarity

10
@太極者無極而生ตกลงกัน - ภาพนี้สวยทำให้เข้าใจผิดเพราะจะทำให้มันมีลักษณะเหมือนgit pullจะกระโดดข้ามดึงข้อมูลซึ่งแน่นอนไม่ถูกต้อง
forresthopkinsa

9
อะไรคือความแตกต่างระหว่าง 'ที่เก็บในพื้นที่' และ 'สำเนาที่ใช้งานได้' พวกเขาทั้งสองอยู่ในเครื่องคอมพิวเตอร์หรือไม่
theITvideos

1
การใช้ git fetch คืออะไร? วิธีดูว่ามีความแตกต่างในพื้นที่เก็บข้อมูลท้องถิ่นและสำเนาการทำงานอย่างไร
Vikash

2
@theITvideos ไม่มันไม่ใช่ ที่เก็บข้อมูลโลคัลคือที่ที่โค้ดของคุณไป (จากที่เก็บที่ทำงาน) เมื่อคุณส่งมอบ (มันจะไปที่ repo ระยะไกลเมื่อคุณกด)
Vikash

219

สั้น

git fetchคล้ายกับpullแต่ไม่รวม เช่นจะดึงการอัปเดตระยะไกล ( refsและobjects) แต่เครื่องของคุณยังคงเหมือนเดิม (เช่นorigin/masterได้รับการอัปเดต แต่masterยังคงเหมือนเดิม)

git pull ดึงลงจากระยะไกลและผสานทันที

มากกว่า

git clone โคลน repo

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

นอกจากนี้git branch -aจะแสดงให้คุณเห็นอย่างชัดเจนว่าเกิดอะไรขึ้นกับสาขาทั้งหมดของคุณ - ท้องถิ่นและระยะไกล

โพสต์บล็อกนี้มีประโยชน์:

ความแตกต่างระหว่าง git pull, git fetch และ git clone (และ rebase git) - Mike Pearce

และครอบคลุมgit pull, git fetch, และgit clonegit rebase

====

UPDATE

ฉันคิดว่าฉันจะอัปเดตสิ่งนี้เพื่อแสดงว่าคุณใช้สิ่งนี้ในทางปฏิบัติอย่างไร

  1. อัพเดต repo ในพื้นที่ของคุณจากระยะไกล (แต่ไม่รวม):

    git fetch 
    
  2. หลังจากดาวน์โหลดการอัปเดตเราจะเห็นความแตกต่าง:

    git diff master origin/master 
    
  3. หากคุณพอใจกับการอัปเดตเหล่านั้นให้ผสาน:

    git pull
    

หมายเหตุ:

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

ในขั้นตอนที่ 3: อาจแม่นยำกว่า (เช่นใน repo ที่เปลี่ยนแปลงอย่างรวดเร็ว) เพื่อทำgit rebase originที่นี่ ดูความคิดเห็น @Justin Ohmsในคำตอบอื่น

ดูเพิ่มเติมที่: http://longair.net/blog/2009/04/16/git-fetch-and-merge/


1
เสียงที่ฉันชอบถ้ามีคนเพียงแค่ต้องการรหัสท้องถิ่นเพื่อสะท้อนให้เห็นถึง "เคล็ดลับ" git cloneพวกเขาควรจะใช้ ฉันใส่เคล็ดลับในคำพูดตามที่ฉันคิดว่ามันจะหมายถึงสิ่งที่เป็นหลักและสิ่งที่ใครบางคนจะ "ดาวน์โหลดเป็น zip" จาก github.com
Chris K

3
เกิดอะไรขึ้นถ้าคุณไม่พอใจกับการเปลี่ยนแปลงหลังจากที่คุณดึงข้อมูลออกมา? จะทำอย่างไรต่อไป
Kugutsumen

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

178
git-pull - ดึงข้อมูลจากและผสานกับที่เก็บอื่นหรือสาขาท้องถิ่น
สรุป

git pull ...
รายละเอียด

รัน git-fetch ด้วยพารามิเตอร์ที่กำหนดและเรียก git-merge เพื่อรวม 
ดึงหัวเข้าไปในสาขาปัจจุบัน ด้วย --rebase โทร git-rebase
แทน git-merge

โปรดทราบว่าคุณสามารถใช้ (ไดเรกทอรีปัจจุบัน) เป็น <repository> เพื่อดึง
จากที่เก็บโลคัล - สิ่งนี้มีประโยชน์เมื่อผสานสาขาโลคัล 
เข้าสู่สาขาปัจจุบัน

นอกจากนี้โปรดทราบว่าตัวเลือกนั้นมีความหมายสำหรับ git-pull และ git-merge 
ต้องให้ก่อนตัวเลือกที่มีความหมายสำหรับ git-fetch

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


5
น่าสนใจมาก แต่ฉันไม่เห็นกรณีการใช้งานที่คุณต้องการ "แค่โค้ด" เกิดอะไรขึ้นกับรหัสของคุณเมื่อคุณดึงข้อมูล มันจะถูกลบ? เกิดอะไรขึ้นเมื่อการเปลี่ยนแปลงทางไกล มันจะเข้าสู่ repo ของคุณได้อย่างไรโดยไม่ต้องลบรหัสหากคุณไม่รวม
E-satis

11
@ e-พอน: สาขาระยะไกลจะถูกเก็บไว้ในเครื่องของคุณ ดังนั้นเมื่อคุณgit fetchดึงข้อมูลการเปลี่ยนแปลงจากที่เก็บและอัปเดตสาขาระยะไกลในพื้นที่ของคุณ ไม่ส่งผลกระทบต่อสาขาในพื้นที่ของคุณที่ติดตามสาขาระยะไกลในพื้นที่ดังนั้นจะไม่มีผลกับสำเนาทำงานของคุณ ตอนนี้เมื่อคุณทำmergeมันจะรวมการเปลี่ยนแปลงที่ดึงมากับสาขาท้องถิ่นของคุณ
jeffreyveon

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

163

คุณสามารถดึงข้อมูลจากที่เก็บระยะไกลดูความแตกต่างแล้วดึงหรือผสาน

นี่คือตัวอย่างสำหรับที่เก็บรีโมตที่เรียกoriginและสาขาที่เรียกว่าmasterการติดตามรีโมตสาขาorigin/master:

git checkout master                                                  
git fetch                                        
git diff origin/master
git rebase origin master

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

158

คำตอบสั้น ๆ และง่ายก็คือว่าgit pullเป็นเพียงการตามgit fetchgit merge

มันเป็นสิ่งสำคัญมากที่จะทราบว่าgit pullจะผสานโดยอัตโนมัติไม่ว่าคุณจะชอบหรือไม่ แน่นอนว่าสิ่งนี้อาจส่งผลให้เกิดข้อขัดแย้งในการผสาน สมมติว่าระยะไกลของคุณเป็นและสาขาของคุณorigin masterหากคุณgit diff origin/masterก่อนที่จะดึงคุณควรมีความคิดของความขัดแย้งผสานที่อาจเกิดขึ้นและสามารถเตรียมสาขาท้องถิ่นของคุณตามลำดับ

นอกเหนือจากการดึงและผลักดันแล้วเวิร์กโฟลว์บางตัวยังเกี่ยวข้องgit rebaseเช่นนี้ซึ่งฉันถอดความจากบทความที่เชื่อมโยง:

git pull origin master
git checkout foo-branch
git rebase master
git push origin foo-branch

git pull --rebaseหากคุณพบว่าตัวเองอยู่ในสถานการณ์เช่นนี้คุณอาจถูกล่อลวงไป เว้นแต่คุณจะรู้ว่าคุณกำลังทำอะไรอยู่จริงๆ คำเตือนนี้มาจากmanหน้าสำหรับgit-pullเวอร์ชั่น2.3.5:

นี่เป็นโหมดการทำงานที่อาจเป็นอันตราย มันเขียนประวัติซึ่งไม่เป็นลางดีเมื่อคุณเผยแพร่ประวัตินั้นแล้ว อย่าใช้ตัวเลือกนี้ยกเว้นว่าคุณได้อ่าน git-rebase (1) อย่างถี่ถ้วน


2
@JustinOhms หากgit pull --rebaseไม่ใช่สิ่งที่ถูกต้องในสถานการณ์ที่กำหนดมันถูกต้องหรือไม่หากทำได้สองขั้นตอน? หากเป็นสิ่งที่ถูกต้องที่จะทำอะไรประโยชน์พิเศษของการทำในสองขั้นตอนคืออะไร
Kaz

@Kaz - เนื่องจากการ rebase ไม่อัตโนมัติ การดึงข้อมูลการเปลี่ยนแปลงก่อนอนุญาตให้คุณทำการเรียกใช้วิจารณญาณ มันไม่ได้แก้ไขปัญหาเกี่ยวกับประวัติการรีบูตที่คุณผลักดันไปแล้ว มันจะช่วยให้คุณดูว่ามันปลอดภัยที่จะรีบูตการเปลี่ยนแปลงที่คุณยังไม่ได้ผลัก
Justin Ohms

2
@JustinOhms คุณจะตัดสินใจได้อย่างไรว่าปลอดภัยในการรีบูตการเปลี่ยนแปลง ฉันจะลอง rebit คอมไพล์และ backtrack ถ้ามันเลอะซึ่งในกรณีนี้ฉันอาจทำ git pull --rebase แต่บางทีคุณมีวิธีอื่นบ้าง
Kaz

3
@KaZ gitk ช่วยให้คุณเห็นโครงสร้างของสาขาด้วยสายตา มันจะแสดงตำแหน่งของหัวหน้าท้องถิ่นรีโมทของคุณและโครงสร้างสาขาของคุณซึ่งสัมพันธ์กับสิ่งที่คุณดึงมา วิธีนี้คุณสามารถมั่นใจได้ว่าคุณไม่ได้ทำการรีบูตการเปลี่ยนแปลงที่เกิดจากบรรพบุรุษที่อยู่ก่อนหน้าสิ่งที่คุณผลักไปยังรีโมตแล้ว
Justin Ohms

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

151

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

เรียก git

มันจะดาวน์โหลดrefsและวัตถุทั้งหมดและสาขาใหม่ใด ๆ ในพื้นที่เก็บข้อมูลในพื้นที่ของคุณ ...

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

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

git fetch สามารถดึงข้อมูลจากแหล่งเก็บข้อมูลที่มีชื่อเดียวหรือ URL หรือจากที่เก็บหลายแห่งพร้อมกันหากได้รับและมีรีโมต รายการในไฟล์กำหนดค่า (ดู git-config 1 )

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

ชื่อของ refs ที่ดึงมาพร้อมกับชื่อวัตถุที่พวกเขาชี้ไปจะถูกเขียนไปยัง. git / FETCH_HEAD ข้อมูลนี้อาจถูกใช้โดยสคริปต์หรือคำสั่ง git อื่น ๆ เช่น git-pull


git pull

มันจะใช้การเปลี่ยนแปลงจากระยะไกลกับสาขาปัจจุบันในท้องถิ่น ...

รวมการเปลี่ยนแปลงจากที่เก็บระยะไกลเข้ากับสาขาปัจจุบัน ในโหมดเริ่มต้นการดึง git นั้นเป็นการจดชวเลขสำหรับ git fetch แล้วตามด้วย git merge FETCH_HEAD

แม่นยำยิ่งขึ้น git pull รัน git fetch ด้วยพารามิเตอร์ที่กำหนดและเรียก git merge เพื่อผสานส่วนหัวสาขาที่ดึงมาไว้ในสาขาปัจจุบัน ด้วย --rebase มันจะทำการรีบูต git แทน git merge

ควรเป็นชื่อของพื้นที่เก็บข้อมูลระยะไกลผ่านไป Git-fetch 1 สามารถตั้งชื่อการอ้างอิงระยะไกลโดยพลการ (ตัวอย่างเช่นชื่อของแท็ก) หรือแม้แต่ชุดการอ้างอิงที่มีสาขาการติดตามระยะไกลที่สอดคล้องกัน (เช่น refs / heads / : refs / remotes / origin / ) แต่โดยปกติจะเป็นชื่อ สาขาในที่เก็บระยะไกล

ค่าเริ่มต้นสำหรับและอ่านจากการกำหนดค่า "ระยะไกล" และ "ผสาน" สำหรับสาขาปัจจุบันตามที่กำหนดโดย git-branch --track


ฉันยังสร้างภาพด้านล่างเพื่อแสดงให้คุณเห็นวิธีgit fetchและgit pullทำงานร่วมกัน ...

git pull และ git fetch


10
ถ้าคุณชอบภาพแล้วดูที่คอมไพล์แผ่นโกงซึ่งเป็นประเภทเดียวกันของสิ่งสำหรับทุกคอมไพล์คำสั่ง ... ndpsoftware.com/git-cheatsheet.html
ทอม

3
การโคลนไม่มีผลกับที่เก็บในเครื่อง (คัดลอกประวัติทั้งหมดจากระยะไกล) หรือไม่
Tom Loredo

135

ป้อนคำอธิบายรูปภาพที่นี่

การแสดงกราฟิกเชิงโต้ตอบนี้มีประโยชน์มากในการทำความเข้าใจกับ git: http://ndpsoftware.com/git-cheatsheet.html

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


18
ผู้คนคลิกที่ลิงค์เพื่อโต้ตอบกับคอลัมน์ต่างๆ สูตรนี้เป็นแหล่งข้อมูลที่ดีที่สุดที่ฉันได้เห็นเพื่อทำความเข้าใจความแตกต่างระหว่างแต่ละคำสั่ง
M. Luisa Carrión

คำตอบนี้ต้องไปด้านบน
Tessaracter

126

โบนัส:

เมื่อพูดถึงการดึงและดึงข้อมูลในคำตอบข้างต้นฉันต้องการแบ่งปันเคล็ดลับที่น่าสนใจ

git pull --rebase

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

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

ค้นหารายละเอียดได้ที่: http://gitolite.com/git-pull--rebase


4
คำแนะนำที่ดีแม้ว่าจะคุ้มค่าที่จะกล่าวถึงผู้ใช้คอมไพล์ใหม่ที่การลดระดับแก้ไขการกระทำแฮช (ฉันพบว่าน่าประหลาดใจที่มาจากการโค่นล้ม)
AlexMA

1
คุณช่วยอธิบายว่าอะไรคือความแตกต่างระหว่างgit pullและgit pull --rebase?
shaijut

2
ดูคำเตือนอย่างสิ้นเชิงเกี่ยวกับวิธีนี้ในคำตอบข้างต้น: stackoverflow.com/a/6011169/241244

118

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

                                         LOCAL SYSTEM
                  . =====================================================    
================= . =================  ===================  =============
REMOTE REPOSITORY . REMOTE REPOSITORY  LOCAL REPOSITORY     WORKING COPY
(ORIGIN)          . (CACHED)           
for example,      . mirror of the      
a github repo.    . remote repo
Can also be       .
multiple repo's   .
                  .
                  .
FETCH  *------------------>*
Your local cache of the remote is updated with the origin (or multiple
external sources, that is git's distributed nature)
                  .
PULL   *-------------------------------------------------------->*
changes are merged directly into your local copy. when conflicts occur, 
you are asked for decisions.
                  .
COMMIT            .                             *<---------------*
When coming from, for example, subversion, you might think that a commit
will update the origin. In git, a commit is only done to your local repo.
                  .
PUSH   *<---------------------------------------*
Synchronizes your changes back into the origin.

ข้อได้เปรียบที่สำคัญบางประการสำหรับการมีกระจกเงาที่ดึงมาจากรีโมทคือ:

  • ประสิทธิภาพ (เลื่อนดูการกระทำและข้อความทั้งหมดโดยไม่พยายามบีบผ่านเครือข่าย)
  • คำติชมเกี่ยวกับสถานะของ repo ในพื้นที่ของคุณ (ตัวอย่างเช่นฉันใช้ SourceTree ของ Atlassian ซึ่งจะให้หลอดไฟแก่ฉันเพื่อระบุว่าฉันมุ่งมั่นข้างหน้าหรือข้างหลังเทียบกับที่มาต้นกำเนิดข้อมูลนี้สามารถอัปเดตด้วย GIT FETCH)

ไม่git pullรวมถึงการผสานเช่นไปตลอดทางสำเนาการทำงานหรือไม่
Kamiel Wanrooij

จุดดีใช่มันจะทำให้การเปลี่ยนแปลงทั้งหมดในสำเนาการทำงานของคุณและจากนั้นคุณสามารถผูกมัดตัวเองลงใน repo ท้องถิ่น ฉันจะปรับปรุงภาพ
Justus Romijn

@JustusRomijn การดึงยังไม่อัปเดตที่เก็บในเครื่องหรือไม่ ไม่ควรมีเครื่องหมายดอกจันอยู่ระหว่างต้นกำเนิดกับเครื่องหมายดอกจันที่ใช้งานได้
764754

2
@ user764754 เมื่อคุณดึงสำเนาการทำงานของคุณจะได้รับการเปลี่ยนแปลง (อาจมีข้อขัดแย้งบางอย่างซึ่งคุณอาจต้องแก้ไข) คุณยังต้องยอมรับมันในพื้นที่เก็บข้อมูลในท้องถิ่นของคุณ
Justus Romijn

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

106

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

สาม repos ที่มีการดึงข้อมูล:

---------------------     -----------------------     -----------------------
- Remote Repo       -     - Remote Repo         -     - Remote Repo         -
-                   -     - gets pushed         -     -                     -
- @ R01             -     - @ R02               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Repo        -     - Local Repo          -     - Local Repo          -
- pull              -     -                     -     - fetch               -
- @ R01             -     - @ R01               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Sandbox     -     - Local Sandbox       -     - Local Sandbox       -
- Checkout          -     - new work done       -     -                     -
- @ R01             -     - @ R01+              -     - @R01+               -
---------------------     -----------------------     -----------------------

สาม repos ด้วยการดึง

---------------------     -----------------------     -----------------------
- Remote Repo       -     - Remote Repo         -     - Remote Repo         -
-                   -     - gets pushed         -     -                     -
- @ R01             -     - @ R02               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Repo        -     - Local Repo          -     - Local Repo          -
- pull              -     -                     -     - pull                -
- @ R01             -     - @ R01               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Sandbox     -     - Local Sandbox       -     - Local Sandbox       -
- Checkout          -     - new work done       -     - merged with R02     -
- @ R01             -     - @ R01+              -     - @R02+               -
---------------------     -----------------------     -----------------------

สิ่งนี้ช่วยให้ฉันเข้าใจว่าเหตุใดการดึงข้อมูลจึงสำคัญ


ไม่ใช่เรื่องยากที่จะอ่าน: กล่องแสดงสถานะของธุรกรรมซื้อคืนซึ่งในแต่ละแถวจะเปลี่ยนเวลาจากซ้ายไปขวาหลังจากการรายงานในแถว 2 ของกล่อง ป้ายกำกับ R0n เป็นแท็กในคอมไพล์และแท็กที่มีเครื่องหมาย + ยังไม่ใช่สิ่งที่ไม่ธรรมดา Sanbox ใช้สำหรับโฟลเดอร์การทำงานของคุณซึ่งแตกต่างจากโฟลเดอร์ repo ที่เก็บสิ่งที่ฝากไว้
user1708042

96

ความแตกต่างระหว่างGIT FetchและGIT Pullสามารถอธิบายได้ในสถานการณ์ต่อไปนี้: (โปรดจำไว้ว่ารูปภาพพูดได้ดังกว่าคำพูด! ฉันได้แสดงภาพแทน)

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

ดังนั้น รัฐครั้งแรกของทั้งสองสาขาเมื่อคุณคดเคี้ยวโครงการหลักในพื้นที่เก็บข้อมูลในท้องถิ่นของคุณจะเป็นเช่น this- ( A, BและCเป็นโมดูลแล้วเสร็จของโครงการ)

ป้อนคำอธิบายรูปภาพที่นี่

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

ป้อนคำอธิบายรูปภาพที่นี่

เพื่อหลีกเลี่ยงปัญหาดังกล่าวและทำงานคู่ขนานกับความก้าวหน้าดั้งเดิมของโครงการของพวกเขามีสองวิธี:

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

ป้อนคำอธิบายรูปภาพที่นี่

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

ป้อนคำอธิบายรูปภาพที่นี่

2. Git Pull-สิ่งนี้จะอัปเดตสาขาในประเทศของคุณด้วยที่มา / สาขาหลักเช่นที่จริงแล้วมันคืออะไรการรวมกันของ Git Fetch และ Git ผสานเข้าด้วยกัน แต่สิ่งนี้อาจทำให้เกิดความขัดแย้งเกิดขึ้นดังนั้นขอแนะนำให้ใช้ Git Pull พร้อมกับสำเนาที่สะอาด

ป้อนคำอธิบายรูปภาพที่นี่


1
หากคุณสามารถเปลี่ยน 'สาขาหลัก' เป็น 'Repo ระยะไกล' มันจะเป็นคำตอบที่ดี
Qibiron ผู้ที่

87

เราก็พูดว่า:

git pull == git fetch + git merge

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

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


3
ฉันอยากจะบอกว่าgit pull == git fetch + git merge:)
melvynkim

2
แต่git pull --rebase = git fetch + git rebase
Tino

83

git fetchดึงรหัสจากเซิร์ฟเวอร์ระยะไกลไปยังสาขาการติดตามของคุณในที่เก็บในเครื่องของคุณ ถ้าระยะไกลของคุณเป็นชื่อorigin(เริ่มต้น) แล้วสาขาเหล่านี้จะได้รับภายในorigin/เช่นorigin/master, origin/mybranch-123ฯลฯ เหล่านี้ไม่ได้เป็นสาขาในปัจจุบันของพวกเขามีในท้องถิ่นสำเนาของสาขาเหล่านั้นมาจากเซิร์ฟเวอร์

git pullทำอย่างไรgit fetchแต่ยังผสานรหัสจากสาขาการติดตามเป็นสาขาท้องถิ่นปัจจุบันของสาขานั้น หากคุณยังไม่พร้อมสำหรับการเปลี่ยนแปลงให้ทำgit fetchก่อน


78

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


73

Git Fetch

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

Git Merge

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

Git Pull

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


51

ข้อแตกต่างระหว่างgit pullและgit fetchคือ:

git pull ดึงจากสาขาระยะไกลและผสาน

git fetch ดึงเฉพาะจากสาขาระยะไกล แต่มันไม่ได้ผสาน

ie git pull = git fetch + git merge ...


1
และไม่ช่วยถ้าคอมไพล์คิดว่าคุณอยู่ข้างหลังด้วยความมุ่งมั่นและสามารถ "ส่งต่ออย่างรวดเร็ว" ซึ่งเมื่อฉันลงเอยด้วยrm -rfการทำสิ่งทั้งหมดและเริ่มต้นใหม่ โง่ Git โปรดให้ฉันได้รับปัจจุบันเพื่อให้ฉันสามารถกลับไปทำงานได้หรือไม่
Chris K

47

ในแง่ง่ายๆถ้าคุณกำลังจะกระโดดขึ้นไปบนเครื่องบินได้โดยไม่ต้องเชื่อมต่ออินเทอร์เน็ตใด ๆ ... git fetch origin <master>ก่อนที่จะแยกย้ายคุณก็สามารถทำ มันจะดึงข้อมูลการเปลี่ยนแปลงทั้งหมดในคอมพิวเตอร์ของคุณ แต่ให้แยกจากการพัฒนา / พื้นที่ทำงานในท้องถิ่นของคุณ

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


จากการกวดวิชา Atlassian ที่น่ากลัวนี้:

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

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

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


ด้วยgit pull:

  • คุณไม่ได้อยู่คนเดียว
  • มันมีผลต่อการพัฒนาท้องถิ่นของคุณ
  • ไม่จำเป็นต้องเช็คเอาต์อย่างชัดเจน git mergeเพราะมันไม่ได้โดยปริยาย
  • มันไม่ปลอดภัย มันก้าวร้าว
  • ซึ่งแตกต่างจากgit fetchที่มีผลกับคุณเพียงอย่างเดียวการ.git/refs/remotesดึง git จะส่งผลต่อทั้งของคุณ.git/refs/remotes และ .git/refs/heads/

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

เป็นคำถามที่ดีมาก มันทำให้มันแยกจากสำเนาการทำงานของคุณ แต่อีกครั้งที่ไหน มาหาคำตอบกัน

ในไดเรกทอรีโครงการของคุณ (เช่นที่คุณทำgitคำสั่งของคุณ) ทำ:

  1. ls. นี่จะแสดงไฟล์ & ไดเรกทอรี ไม่มีอะไรเจ๋งฉันรู้

  2. ls -aตอนนี้ทำ นี้จะแสดงไฟล์จุดคือไฟล์ที่เริ่มต้นด้วยแล้วคุณจะสามารถดูไดเรกทอรีชื่อ:..git

  3. cd .gitDo สิ่งนี้จะเปลี่ยนไดเรกทอรีของคุณอย่างชัดเจน
  4. ตอนนี้ส่วนที่สนุกมา; lsทำ คุณจะเห็นรายการไดเรกทอรี refsเรากำลังมองหา cd refsDo
  5. เป็นที่น่าสนใจที่จะเห็นสิ่งที่อยู่ในไดเรกทอรีทั้งหมด แต่ลองมุ่งเน้นที่สองของพวกเขา และheads remotesใช้cdตรวจสอบภายในพวกเขาด้วย
  6. ใด ๆ git fetchที่คุณทำจะปรับปรุงรายการใน/.git/refs/remotesไดเรกทอรี มันจะไม่อัปเดตอะไรใน/.git/refs/headsไดเรกทอรี
  7. สิ่งใดก็ตามที่ git pullจะทำgit fetchอัปเดตรายการใน/.git/refs/remotesไดเรกทอรีก่อนจากนั้นจึงรวมกับเครื่องของคุณแล้วเปลี่ยนส่วนหัวภายใน/.git/refs/headsไดเรกทอรี

คำตอบที่เกี่ยวข้องที่ดีมากสามารถพบได้ใน'git fetch' วางอยู่ที่ไหน .

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


เพื่อดูความแตกต่างที่แท้จริง

แค่ทำ:

git fetch origin master
git checkout master

หากมีการอัปเดตต้นแบบระยะไกลคุณจะได้รับข้อความเช่นนี้:

Your branch is behind 'origin/master' by 2 commits, and can be fast-forwarded.
  (use "git pull" to update your local branch)

หากคุณไม่ทำfetchและเพิ่งทำgit checkout masterคอมไพล์ท้องถิ่นของคุณจะไม่รู้ว่ามีการเพิ่ม 2 คอมมิท และมันก็จะบอกว่า:

Already on 'master'
Your branch is up to date with 'origin/master'.

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


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

IDE บางตัว (เช่น Xcode) นั้นสุดยอดและใช้ผลลัพธ์ของ a git fetchและสามารถใส่คำอธิบายประกอบบรรทัดของรหัสที่มีการเปลี่ยนแปลงในสาขาระยะไกลของสาขาที่ทำงานปัจจุบันของคุณ หากบรรทัดนั้นได้รับการเปลี่ยนแปลงทั้งจากการเปลี่ยนแปลงในท้องถิ่นและสาขาระยะไกลแสดงว่าบรรทัดนั้นได้รับการเพิ่มความคิดเห็นด้วยสีแดง นี่ไม่ใช่ความขัดแย้งผสาน มันเป็นความขัดแย้งที่อาจเกิดขึ้นได้ มันเป็น headsup ที่คุณสามารถใช้เพื่อแก้ไขข้อขัดแย้งการรวมในอนาคตก่อนที่จะทำgit pullจากสาขาระยะไกล

ป้อนคำอธิบายรูปภาพที่นี่


เคล็ดลับความสนุก:

หากคุณดึงสาขาระยะไกลเช่นทำ:

git fetch origin feature/123

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

git checkout feature/123

คุณไม่จำเป็นต้องทำ:

git checkout -b feature/123 origin/feature/123

อ่านเพิ่มเติมได้ที่นี่


1
ฉันชอบคำตอบนี้
Kid_Learning_C

44

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

  1. การคัดลอกใหม่กระทำจากสาขาระยะไกลเพื่อคัดลอกสาขาระยะไกลนี้ภายใน repo ท้องถิ่น

    (repo เพื่อดำเนินการ repo) master@remote >> remote/origin/master@local

  2. บูรณาการใหม่มุ่งมั่นที่สาขาท้องถิ่น

    (การดำเนินการภายใน repo) remote/origin/master@local >> master@local

มีสองวิธีในการทำขั้นตอนที่ 2 คุณสามารถ:

  1. แยกสาขาโลคัลหลังจากบรรพบุรุษที่พบบ่อยครั้งล่าสุดและเพิ่มคอมมิทใหม่ขนานไปกับคอมมิทที่ไม่ซ้ำกับที่เก็บในพื้นที่
  2. แทรกการคอมมิตใหม่หลังจากบรรพบุรุษที่พบบ่อยครั้งล่าสุดและคอมมิตใหม่ที่ไม่ซ้ำกับที่เก็บในเครื่อง

ในgitคำศัพท์ขั้นตอนที่ 1 คือgit fetchขั้นตอนที่ 2 คือgit mergeหรือgit rebase

git pullเป็นgit fetchและgit merge


37

Git ได้รับสาขาของเวอร์ชั่นล่าสุดจากระยะไกลไปยังท้องถิ่นโดยใช้สองคำสั่ง:

  1. git fetch: Git กำลังจะรับรุ่นล่าสุดจากระยะไกลไปยังท้องถิ่น แต่จะไม่รวมโดยอัตโนมัติ      git fetch origin master git log -p master..origin/master git merge origin/master

         คำสั่งข้างต้นหมายความว่าการดาวน์โหลดสาขาหลักล่าสุดจากแหล่งกำเนิดจากระยะไกลไปยังต้นกำเนิดสาขา จากนั้นทำการเปรียบเทียบสาขาต้นแบบภายในและจุดกำเนิดต้นแบบ สุดท้ายผสาน

  2. git pull: Git กำลังจะรับเวอร์ชั่นล่าสุดจากรีโมทและรวมเข้ากับโลคอล

        git pull origin master

         คำสั่งดังกล่าวเป็นเทียบเท่ากับและgit fetch git mergeในทางปฏิบัติgit fetchอาจมีความปลอดภัยมากกว่าเพราะก่อนการรวมเราจะเห็นการเปลี่ยนแปลงและตัดสินใจว่าจะรวมหรือไม่


37

ความแตกต่างระหว่างgit pullและgit fetchคืออะไร?

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

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

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


35

git pull == (เรียก git + git merge)

การเรียก git ไม่ได้เปลี่ยนเป็นสาขาท้องถิ่น

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


34

พยายามที่จะชัดเจนและเรียบง่าย

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


33

การแสดงภาพกราฟิกอย่างง่ายสำหรับมือใหม่

ป้อนคำอธิบายรูปภาพที่นี่

ที่นี่

git pull  

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

แต่ใน

เรียก git

จะดึงรหัสจากที่เก็บและเราจำเป็นต้องรีบูตด้วยตนเองโดยใช้ git rebase

เช่น: ฉันจะดึงข้อมูลจากเซิร์ฟเวอร์หลักและรีบูตมันในต้นแบบท้องถิ่นของฉัน

1) git pull (rebase จะทำโดยอัตโนมัติ):

git pull origin master

จุดเริ่มต้นที่นี่คือต้นแบบ repo ระยะไกลของคุณเป็นสาขาของคุณ

2) เรียก git (ต้องรีบูตด้วยตนเอง):

git fetch origin master

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

git rebase origin/master

การทำเช่นนี้จะรีบูตรหัสเป็นท้องถิ่น ก่อนหน้านั้นรับรองว่าคุณอยู่ในสาขาที่ถูกต้อง


กราฟที่ดี แต่คุณอาจต้องการอธิบายว่าทำไมคุณถึงใช้ "rebase" เมื่อกราฟระบุว่า "ผสาน"
Guntram Blohm รองรับโมนิก้า

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

33

ที่จริง Git เก็บรักษาสำเนาของรหัสของคุณเองและที่เก็บระยะไกล

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

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

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.