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

ในแง่ที่ง่ายที่สุด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

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

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

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

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

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

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

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

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

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

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

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

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

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

git fetch
git diff ...origin

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

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

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

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

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

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

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

สั้น

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/

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

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

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

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

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

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

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

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

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

คำตอบสั้น ๆ และง่ายก็คือว่า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) อย่างถี่ถ้วน

ตกลงนี่คือข้อมูลบางอย่างเกี่ยวกับ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: http://ndpsoftware.com/git-cheatsheet.html

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

โบนัส:

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

git pull --rebase

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

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

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

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

                                         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)

ฉันได้ต่อสู้กับสิ่งนี้เช่นกัน ในความเป็นจริงฉันมาที่นี่พร้อมกับค้นหา 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+               -
---------------------     -----------------------     -----------------------

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

ความแตกต่างระหว่าง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 พร้อมกับสำเนาที่สะอาด

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

git pull == git fetch + git merge

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

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

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

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

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

Git Fetch

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

Git Merge

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

Git Pull

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

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

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

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

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

ในแง่ง่ายๆถ้าคุณกำลังจะกระโดดขึ้นไปบนเครื่องบินได้โดยไม่ต้องเชื่อมต่ออินเทอร์เน็ตใด ๆ ... 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

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

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

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อาจมีความปลอดภัยมากกว่าเพราะก่อนการรวมเราจะเห็นการเปลี่ยนแปลงและตัดสินใจว่าจะรวมหรือไม่

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

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

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

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

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

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

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

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

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

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

ที่นี่

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

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

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

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

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