it-swarm.asia

ما الفرق بين 'git pull' و 'git fetch'؟

ملاحظة مدير الجلسة: بالنظر إلى أن هذا السؤال قد سبق سبعة وستون إجابة قمت بنشرها (حذف بعضها) ، فكر في ما إذا كنت تساهم في أي شيء جديد قبل نشر واحد آخر.

ما هي الاختلافات بين git pull و git fetch؟

10967
pupeno

في أبسط الشروط ، يقوم git pull بتنفيذ git fetch متبوعًا بـ git merge.

يمكنك القيام بـ git fetch في أي وقت لتحديث فروع التتبع عن بُعد ضمن refs/remotes/<remote>/.

لا تقوم هذه العملية أبدًا بتغيير أي من الفروع المحلية الخاصة بك ضمن refs/heads ، وهي آمنة للقيام دون تغيير نسخة العمل الخاصة بك. لقد سمعت حتى عن الأشخاص الذين يديرون git fetch بشكل دوري في وظيفة cron في الخلفية (على الرغم من أنني لن أوصي بذلك).

git pull هو ما ستفعله لتحديث فرع محلي بإصداره البعيد ، مع تحديث فروعك الأخرى للتتبع عن بُعد.

توثيق بوابة - بوابة السحب :

في الوضع الافتراضي ، git pull هو اختصار لـ git fetch متبوعًا بـ git merge FETCH_HEAD.

9129
Greg Hewgill
  • عندما تستخدم pull ، يحاول Git القيام بعملك تلقائيًا نيابة عنك. إنها حساسة للسياق ، لذلك ستدمج Git أي تعهدات تم سحبها في الفرع الذي تعمل فيه حاليًا. pull تقوم تلقائيًا بدمج الالتزامات دون السماح لك بمراجعتها أولاً . إذا لم تقم بإدارة فروعك عن كثب ، فقد تواجه تعارضات متكررة.

  • عندما fetch ، يجمع Git أي تعهدات من الفرع المستهدف غير موجودة في الفرع الحالي و يخزنها في مستودعك المحلي . ومع ذلك ، لا يتم دمجها مع فرعك الحالي . يعد هذا مفيدًا بشكل خاص إذا كنت بحاجة إلى تحديث مستودعك ، ولكنك تعمل على شيء قد ينكسر إذا قمت بتحديث ملفاتك. لدمج التعيينات في الفرع الرئيسي الخاص بك ، يمكنك استخدام merge.

2008
Mouna Cheikhna

من المهم أن نقارن بين فلسفة تصميم git وفلسفة أداة التحكم في المصادر التقليدية مثل SVN.

تم تصميم التخريب وبنيت مع نموذج العميل/الخادم. يوجد مستودع واحد هو الخادم ، ويمكن للعديد من العملاء جلب رمز من الخادم ، والعمل عليه ، ثم إلزامهم مرة أخرى بالخادم. الافتراض هو أنه يمكن للعميل دائمًا الاتصال بالخادم عندما يحتاج إلى إجراء عملية.

تم تصميم Git لدعم نموذج أكثر توزيعًا دون الحاجة إلى مستودع مركزي (على الرغم من أنه يمكنك بالتأكيد استخدام نموذج إذا أردت). تم تصميم بوابة أيضًا بحيث لا يحتاج العميل و "الخادم" إلى الاتصال بالإنترنت في نفس الوقت. تم تصميم Git بحيث يتمكن الأشخاص الموجودون على رابط غير موثوق من تبادل الكود عبر البريد الإلكتروني ، حتى. من الممكن أن يتم فصل القرص تمامًا وحرق قرص مضغوط لتبادل الرمز عبر بوابة.

من أجل دعم هذا النموذج ، يحتفظ git بمستودع محلي برمزك وكذلك مستودع محلي إضافي يعكس حالة المستودع البعيد. من خلال الاحتفاظ بنسخة من المستودع البعيد محليًا ، يمكن لـ git اكتشاف التغييرات المطلوبة حتى عندما يتعذر الوصول إلى المستودع البعيد. في وقت لاحق عندما تحتاج إلى إرسال التغييرات إلى شخص آخر ، يمكن لـ git نقلها كمجموعة من التغييرات من نقطة زمنية معروفة لمستودع التخزين البعيد.

  • git fetchهو الأمر الذي يقول "قم بتحديث نسختي المحلية من المستودع البعيد."

  • git pullيقول "إحضار التغييرات في المستودع البعيد إلى حيث أحافظ على الكود الخاص بي."

عادةًgit pullيقوم بذلك عن طريق إجراءgit fetchلتحديث النسخة المحلية من مستودع التخزين البعيد ، ثم دمج التغييرات في مستودع الشفرة الخاص بك وربما نسخة العمل الخاصة بك.

الاستيلاء هو مراعاة أن هناك غالبًا على الأقل ثلاث نسخ من المشروع على محطة العمل الخاصة بك. نسخة واحدة هي مستودع خاص بك مع سجل الالتزام الخاص بك. النسخة الثانية هي نسخة العمل الخاصة بك حيث تقوم بالتحرير والبناء. النسخة الثالثة هي نسختك "المخزنة مؤقتًا" المحلية من مستودع التخزين البعيد.

1120
MikeD

هنا صورة Oliver Steele عن كيفية تناسب كل شيء معًا :

enter image description here

إذا كان هناك اهتمام كاف ، أفترض أنه يمكنني تحديث الصورة لإضافة git clone و git merge...

767
Contango

إحدى حالات استخدام git fetch هي أن التالي سيخبرك بأية تغييرات في الفرع البعيد منذ آخر سحب لك ... حتى تتمكن من التحقق قبل إجراء عملية سحب فعلية ، والتي يمكن أن تغير الملفات الموجودة في الفرع الحالي ونسخة العمل.

git fetch
git diff ...Origin
453
mepster

لقد كلفني ذلك بعض الشيء بعض الشيء لفهم ما هو الفرق ، لكن هذا تفسير بسيط. master في مضيفك المحلي هو فرع.

عندما تقوم بنسخ مستودع ، فإنك تجلب المستودع بالكامل لك المضيف المحلي. هذا يعني أنه في ذلك الوقت كان لديك مؤشر أصل/رئيسي إلى HEAD والماجستير يشير إلى نفس HEAD.

عندما تبدأ العمل وتلتزم ، تقدّم المؤشر الرئيسي إلى HEAD + التزاماتك. لكن مؤشر Origin/master لا يزال يشير إلى ما كان عليه عند الاستنساخ.

وبالتالي فإن الفرق سيكون:

  • إذا قمت بتنفيذ git fetch ، فسيتم إحضار جميع التغييرات في المستودع البعيد ( GitHub ) ونقل مؤشر Origin/master إلى HEAD. وفي الوقت نفسه ، سيظل سيد الفرع المحلي لديك يشير إلى المكان الذي يوجد فيه.
  • إذا قمت بتنفيذ git pull ، فسيتم إحضاره بشكل أساسي (كما هو موضح سابقًا) ودمج أي تغييرات جديدة على الفرع الرئيسي الخاص بك ونقل المؤشر إلى HEAD.
355
Gerardo

في بعض الأحيان يساعد التمثيل البصري.

 enter image description here

199
thedarkpassenger

لفترة وجيزة

git fetch يشبه pull لكنه لا يدمج. بمعنى أنه يجلب تحديثات عن بُعد (refs و objects) ولكن يبقى حالتك المحلية كما هي (على سبيل المثال ، يتم تحديث Origin/master ولكن master تظل كما هي).

git pull يسحب من جهاز التحكم عن بعد ويدمج على الفور.

أكثر

git clone استنساخ الريبو.

git rebase يحفظ الأشياء من فرعك الحالي غير الموجود في الفرع الرئيسي إلى منطقة مؤقتة. فرعك هو نفسه كما كان قبل أن تبدأ تغييراتك. لذلك ، git pull -rebase ستسحب التغييرات عن بُعد ، وترجع الفرع المحلي الخاص بك ، وتعيد تشغيل تغييراتك في الجزء العلوي من الفرع الحالي الخاص بك واحداً تلو الآخر حتى تكون محدّثًا.

أيضًا ، git branch -a سيُظهر لك بالضبط ما يجري في جميع فروعك - المحلية والبعيدة.

منشور المدونة هذا كان مفيدًا:

الفرق بين سحب الحفرة وجلب الحفرة واستنساخ بوابة العداد (وإعادة بناء البوابة) - مايك بيرس

وأغلفة git pull و git fetch و git clone و git rebase.

====

تحديث

اعتقدت أنني سأقوم بتحديث هذا لإظهار كيف كنت تستخدم هذا في الواقع في الممارسة العملية.

  1. قم بتحديث الريبو المحلي الخاص بك من جهاز التحكم عن بعد (ولكن لا تندمج):

    git fetch 
    
  2. بعد تنزيل التحديثات ، دعونا نرى الاختلافات:

    git diff master Origin/master 
    
  3. إذا كنت راضيًا عن هذه التحديثات ، فقم بدمج:

    git pull
    

ملاحظات:

في الخطوة 2: لمعرفة المزيد حول الاختلافات بين المحلي وأجهزة التحكم عن بُعد ، راجع: كيفية مقارنة فرع بوابة محلي بفرعه البعيد؟

في الخطوة 3: من المحتمل أن تكون أكثر دقة (على سبيل المثال تغيير سريع في الريبو) للقيام بـ git rebase Origin هنا. انظر @ Justin Ohms comment في إجابة أخرى.

انظر أيضا: http://longair.net/blog/2009/04/16/git-fetch-and-merge/

194
Snowcrash
 git-pull - جلب من ودمج مع مستودع آخر أو فرع محلي 
 خلاصة 
 
 بوابة السحب ... 
 الوصف [....] 
 يتم تشغيل git-fetch مع المعلمات المعينة ، ويدعو git-merge لدمج [(.).] الرأس المسترجع في الفرع الحالي. مع --rebase ، يستدعي git-rebase 
 بدلاً من git-merge. 
 
 لاحظ أنه يمكنك استخدام. (الدليل الحالي) باعتباره <المستودع> لسحب 
 من المستودع المحلي - يعد هذا مفيدًا عند دمج الفروع المحلية 
 في الفرع الحالي. 
 
 أيضًا لاحظ يجب إعطاء تلك الخيارات المخصصة لـ git-pull نفسها و git-merge الأساسي 
 قبل الخيارات المخصصة لـ git-fetch. 

يمكنك السحب إذا كنت ترغب في دمج التواريخ ، فستجلب إذا كنت تريد كودز فقط حيث قام شخص ما بوضع علامة على بعض المقالات هنا.

167
Vinko Vrsalovic

يمكنك إحضارها من مستودع تخزين بعيد ، ورؤية الاختلافات ، ثم السحب أو الدمج.

هذا مثال لمستودع بعيد يسمى Origin وفرع يسمى master تتبع الفرع البعيد Origin/master:

git checkout master                                                  
git fetch                                        
git diff Origin/master
git rebase Origin master
152
Antonio Bardazzi

الإجابة المختصرة والسهلة هي أن git pull هي ببساطة git fetch متبوعة بـ git merge.

من المهم جدًا ملاحظة أن git pull will ستدمج تلقائيًا ما إذا كنت ترغب في ذلك أم لا . هذا يمكن أن يؤدي ، بالطبع ، إلى دمج الصراعات. دعنا نقول أن جهاز التحكم عن بعد هو 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) بعناية.

146
jfmercer

OK، إليك بعض المعلومات حول git pull و git fetch ، لذلك يمكنك فهم الاختلافات الفعلية ... في بضع كلمات بسيطة ، جلب الحصول على أحدث البيانات ، ولكن ليس الرمز التغييرات وعدم الفوضى باستخدام رمز الفرع المحلي الحالي الخاص بك ، ولكن سحب الحصول على تغييرات الرمز ودمجها الفرع المحلي الخاص بك ، قراءة للحصول على مزيد من التفاصيل حول كل:

جلب جلب

سيتم تنزيل الكل المراجع و الكائنات وأي فروع جديدة إلى مستودعك المحلي ...

جلب الفروع و/أو العلامات (مجتمعة ، "المراجع") من واحد أو أكثر من المستودعات الأخرى ، إلى جانب الكائنات اللازمة لإكمال تاريخها. يتم تحديث فروع التتبع عن بُعد (انظر وصف أدناه للحصول على طرق للتحكم في هذا السلوك).

افتراضيًا ، يتم أيضًا جلب أي علامة تشير إلى التواريخ التي يتم جلبها ؛ التأثير هو إحضار العلامات التي تشير إلى الفروع التي تهتم بها. يمكن تغيير هذا السلوك الافتراضي باستخدام خيارات - علامات أو - لا علامات أو عن طريق تكوين remote..tagOpt. باستخدام refspec الذي يجلب العلامات بشكل صريح ، يمكنك جلب علامات لا تشير إلى فروع تهتم بها أيضًا.

يمكن إحضار git fetch إما من مستودع واحد أو مستودع URL مسماة ، أو من عدة مستودعات في آنٍ واحد إذا تم تقديمه ، وهناك أجهزة للتحكم عن بعد. الدخول في ملف التكوين. (انظر git-config 1 ).

عند عدم تحديد أي جهاز تحكم عن بعد ، سيتم استخدام جهاز التحكم عن بعد في الأصل ، ما لم يكن هناك فرع upstream مكون للفرع الحالي.

تتم كتابة أسماء المراجع التي يتم جلبها مع أسماء الكائنات التي يشيرون إليها على .git/FETCH_HEAD. يمكن استخدام هذه المعلومات عن طريق البرامج النصية أو أوامر git الأخرى ، مثل git-pull.


بوابة سحب

سيتم تطبيق التغييرات من بعيد إلى الفرع الحالي في المحلية ...

يدمج التغييرات من مستودع بعيد إلى الفرع الحالي. في الوضع الافتراضي ، يكون git pull اختصارًا لجلب git متبوعًا بدمج git merge FETCH_HEAD.

بتعبير أدق ، يتم تشغيل git pull مع جلب المعلمات المحددة ويدعو git merge لدمج رؤوس الفروع المسترجعة في الفرع الحالي. مع --rebase ، يتم تشغيل rebase git بدلاً من دمج git.

يجب أن يكون اسم المستودع عن بعد كما تم تمريره إلى git-fet/ 1 . يمكن تسمية مرجع تعسفي عن بعد (على سبيل المثال ، اسم علامة) أو حتى مجموعة من المرجعيات مع فروع التتبع عن بُعد المقابلة (على سبيل المثال ، refs/heads/_ {: refs/remotes/Origin /) ، ولكن عادة ما يكون اسم الفرع في المستودع البعيد.

تتم قراءة القيم الافتراضية من التكوين "البعيد" و "الدمج" للفرع الحالي وقراءته وفقًا لتعيين git-branch --track.


أقوم أيضًا بإنشاء visual أدناه لتوضح لك كيف يعمل كل من git fetch و git pull ...

 git pull and git fetch

129
Alireza

enter image description here

هذا التمثيل التفاعلي التفاعلي مفيد للغاية في فهم بوابة: http://ndpsoftware.com/git-cheatsheet.html

git fetch فقط "تنزيل" التغييرات من جهاز التحكم عن بعد إلى مستودع التخزين المحلي. git pull يقوم بتنزيل التغييرات ودمجها في فرعك الحالي. "في الوضع الافتراضي ، git pull اختصار لـ git fetch متبوعًا بـ git merge FETCH_HEAD."

123
th3sly

علاوة:

عند الحديث عن السحب والإحضار في الإجابات أعلاه ، أود أن أشارك خدعة ممتعة ،

git pull --rebase

هذا الأمر أعلاه هو الأمر الأكثر فائدة في حياتي التي وفرت الكثير من الوقت.

قبل دفع التعهدات الجديدة إلى الخادم ، جرب هذا الأمر وسيقوم تلقائيًا بمزامنة آخر تغييرات الخادم (مع جلب + دمج) وسيضع التزامك في الجزء العلوي في سجل git. لا داعي للقلق بشأن السحب/الدمج اليدوي.

البحث عن التفاصيل في: http://gitolite.com/git-pull--rebase

119
Sazzad Hissain Khan

أحب أن أحصل على تمثيل مرئي للموقف لفهم هذه الأشياء. ربما يود مطورون آخرون رؤيته أيضًا ، فإليك هذه الإضافة. لست متأكدًا تمامًا من صحة كل شيء ، لذا يرجى التعليق إذا وجدت أي أخطاء.

                                         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.

بعض المزايا الرئيسية لوجود نسخة متطابقة من جهاز التحكم عن بعد هي:

  • الأداء (قم بالتمرير خلال جميع الإرسالات والرسائل دون محاولة الضغط عليه عبر الشبكة)
  • تعليقات حول حالة الريبو المحلي الخاص بك (على سبيل المثال ، أستخدم SourceTree لـ Atlassian ، والذي سوف يعطيني لمبة تشير إلى ما إذا كنت ارتكبت أمامي أو خلفه مقارنة بالمنشأ. يمكن تحديث هذه المعلومات باستخدام GIT FETCH ).
110
Justus Romijn

لقد كافحت مع هذا أيضا. في الواقع ، وصلت إلى هنا مع بحث google لنفس السؤال بالضبط. قراءة كل هذه الإجابات أخيراً رسمت صورة في رأسي وقررت أن أحاول أن أنظر إلى حالة المستودعين و 1 رمل وإجراءات يتم تنفيذها مع مرور الوقت أثناء مشاهدة نسخة منها. لذلك هنا ما توصلت إليه. يرجى تصحيح لي إذا كنت افسدت في أي مكان.

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+               -
---------------------     -----------------------     -----------------------

ساعدني هذا في فهم سبب أهمية عملية الجلب.

102
pn1 dude

يمكن تفسير الفرق بين GIT Fetch و GIT Pull بالسيناريو التالي: (مع الأخذ في الاعتبار أن الصور تتحدث بصوت أعلى من الكلمات! ، لقد قدمت تمثيلًا تصويريًا)

لنأخذ مثالاً على أنك تعمل في مشروع مع أعضاء فريقك. لذلك ستكون إرادتهم فرعًا رئيسيًا واحدًا من المشروع ، ويجب على جميع المساهمين أن يتجهوا إلى المستودع المحلي الخاص بهم ، ثم العمل على هذا الفرع المحلي لتعديل/إضافة الوحدات النمطية ثم العودة إلى الفرع الرئيسي.

لذلك ، الحالة الأولية من الفرعين عندما كنت متشعب المشروع الرئيسي على مستودع المحلي الخاص بك سيكون مثل هذا- (A ، B و C هي وحدات اكتملت بالفعل من المشروع)

 enter image description here

الآن ، بدأت العمل على الوحدة النمطية الجديدة (افترض D) وعند الانتهاء من الوحدة النمطية D التي ترغب في دفعها إلى الفرع الرئيسي ، لكن ما يحدث هو أن أحد زملائك في الفريق قد طوّر Module جديد E و F و تعديل C.
الآن ما حدث هو أن مستودعك المحلي يفتقر إلى التقدم الأصلي للمشروع ، وبالتالي دفع تغييراتك إلى الفرع الرئيسي يمكن أن يؤدي إلى تعارض وقد يتسبب في خلل الوحدة النمطية D.

 enter image description here

لتجنب مثل هذه المشكلات والعمل بالتوازي مع التقدم الأصلي للمشروع ، توجد طريقتان:

1. Git Fetch- سيؤدي هذا إلى تنزيل جميع التغييرات التي تم إجراؤها على مشروع الفرع الرئيسي/الأصل والتي لا وجود لها في فرعك المحلي. وسوف ينتظر الأمر Git Merge لتطبيق التغييرات التي تم جلبها إلى مستودعك أو الفرع الخاص بك.

 enter image description here

يمكنك الآن مراقبة الملفات بعناية قبل دمجها في مستودعك. ويمكنك أيضًا تعديل D إذا لزم الأمر بسبب التعديل C.

 enter image description here

2. Git Pull- سيؤدي هذا إلى تحديث الفرع المحلي بفرع الأصل/الرئيسي ، أي ما يفعله في الواقع هو مزيج من Git Fetch و Git دمج واحد تلو الآخر. ولكن هذا قد يتسبب في حدوث تعارضات ، لذلك يوصى باستخدام Git Pull مع نسخة نظيفة.

 enter image description here

90
Aman Tiwari

نقول ببساطة:

git pull == git fetch + git merge

إذا قمت بتشغيل git pull ، فلن تحتاج إلى دمج البيانات في المحلية. إذا قمت بتشغيل git fetch ، فهذا يعني أنه يجب عليك تشغيل git merge للحصول على أحدث رمز إلى جهازك المحلي. خلاف ذلك ، لن يتم تغيير رمز الجهاز المحلي دون دمج.

لذلك في Git Gui ، عندما تجلب ، عليك دمج البيانات. لن يؤدي إحضار نفسه إلى إجراء تغييرات على التعليمات البرمجية في منطقتك. يمكنك التحقق من ذلك عندما تقوم بتحديث الكود عن طريق جلبه مرة واحدة وإحضاره. الرمز لن يتغير. ثم قمت بدمج ... سترى الرمز الذي تم تغييره.

82
Selvamani

git fetch يسحب الرمز من الخادم البعيد إلى فروع التتبع في مستودعك المحلي. إذا تم تسمية جهاز التحكم عن بُعد بـ Origin (الافتراضي) ، فستكون هذه الفروع ضمن Origin/ ، على سبيل المثال Origin/master ، Origin/mybranch-123 ، إلخ. هذه ليست فروعك الحالية ، فهي محلية نسخ من هذه الفروع من الخادم.

git pull يقوم بتنفيذ git fetch ولكن بعد ذلك - أيضًا يدمج الكود من فرع التتبع في الإصدار المحلي الحالي لهذا الفرع. إذا لم تكن مستعدًا للتغييرات بعد ، فما عليك سوى git fetch أولاً.

80
Michael Durrant

git fetch سوف يسترجع الفروع البعيدة بحيث يمكنك git diff أو git merge من الفروع الحالية. git pull سيتم تشغيل الجلب على brach البعيد الذي تتبعه الفرع الحالي ثم دمج النتيجة. يمكنك استخدام git fetch لمعرفة ما إذا كان هناك أي تحديثات للفرع البعيد دون الحاجة إلى دمجها مع الفرع المحلي الخاص بك.

75
ntanase

Git Fetch

يمكنك تنزيل التغييرات إلى فرعك المحلي من Origin عبر الجلب. يسأل Fetch الريبو البعيد عن جميع الالتزامات التي قام بها الآخرون ولكنك لا تملكها في الريبو المحلي. يقوم الجلب بتنزيل هذه الالتزامات وإضافتها إلى المستودع المحلي.

بوابة جيت

يمكنك تطبيق التغييرات التي تم تنزيلها من خلال الجلب باستخدام أمر الدمج. سيأخذ الدمج الالتزامات التي تم استردادها من الجلب ومحاولة إضافتها إلى الفرع المحلي. سوف يحتفظ الدمج بسجل الالتزام بالتغييرات المحلية بحيث عندما تشارك فرعك مع Push ، سيعرف Git كيف يمكن للآخرين دمج تغييراتك.

بوابة السحب

يعمل الجلب والاندماج معًا في كثير من الأحيان بما فيه الكفاية بحيث تم إنشاء أمر يجمع بين الاثنين ، وسحب ،. السحب يقوم بجلب ثم دمج لإضافة الإضافات التي تم تنزيلها إلى فرعك المحلي.

70
Pinkesh Sharma

الفرق الوحيد بين git pull و git fetch هو أن:

git pull تسحب من فرع بعيد ودمجه.

git fetch يتم جلبه فقط من الفرع البعيد ولكنه لا يدمج

على سبيل المثال git pull = git fetch + git merge ...

49
Rohitashv Singhal

Git يسمح بتطبيق الالتزامات القديمة زمنياً بعد الالتزامات الأحدث. لهذا السبب ، يتم تقسيم عملية نقل التعهدات بين المستودعات إلى خطوتين:

  1. نسخ تعهدات جديدة من فرع بعيد إلى نسخة من هذا الفرع البعيد داخل الريبو المحلي.

    (repo to repo العملية) [email protected] >> remote/Origin/[email protected]

  2. دمج التعهدات الجديدة بالفرع المحلي

    (داخل عملية الريبو) remote/Origin/[email protected] >> [email protected]

هناك طريقتان للقيام بالخطوة 2. يمكنك:

  1. تفرع الفرع المحلي بعد آخر سلف مشترك وإضافة التزامات جديدة موازية لالتزامات فريدة من نوعها لمستودع المحلي ، الانتهاء من دمج الالتزام ، وإغلاق مفترق الطرق.
  2. أدخل التعديالت الجديدة بعد آخر سلف مشترك وأعد تطبيق التعهدات الفريدة للمستودع المحلي.

في git المصطلحات ، الخطوة 1 هي git fetch ، والخطوة 2 هي git merge أو git rebase

git pull هو git fetch و git merge

43
Pawel Furmaniak

يحصل Git على فرع أحدث إصدار من جهاز التحكم عن بعد إلى المحلي باستخدام أمرين:

  1. git fetch: ستحصل Git على أحدث إصدار من بعيد إلى محلي ، لكنها لا تندمج تلقائيًا. git fetch Origin mastergit log -p master..Origin/mastergit merge Origin/master

    الأوامر المذكورة أعلاه تعني تنزيل أحدث نسخة من الفرع الرئيسي من Origin من جهاز التحكم عن بعد إلى فرع Origin الرئيسي. ثم يقارن الفرع الرئيسي المحلي والفرع الرئيسي المنشأ. وأخيرا ، دمج.

  2. git pull: Git ستحصل على أحدث إصدار من جهاز التحكم عن بُعد وتندمج في الإصدار المحلي.

    git pull Origin master

    الأمر أعلاه هو المكافئ لـ git fetch و git merge. في الممارسة العملية ، ربما يكون git fetch أكثر أمانًا لأنه قبل الدمج ، يمكننا رؤية التغييرات وتحديد ما إذا كنت تريد الدمج.

35
Marcus Thornton

ما الفرق بين git pull و git fetch؟

لفهم هذا ، عليك أولاً أن تفهم أن بوابةك المحلية لا تحتفظ فقط بمستودعك المحلي ، ولكنها تحتفظ أيضًا بنسخة محلية من المستودع البعيد.

git fetch يحضر نسختك المحلية من المستودع عن بعد. على سبيل المثال ، إذا كان المستودع البعيد الخاص بك هو GitHub - فقد ترغب في إحضار أي تغييرات تم إجراؤها في المستودع البعيد إلى نسختك المحلية منه المستودع البعيد. سيتيح لك ذلك إجراء عمليات مثل المقارنة أو الدمج.

git pull من ناحية أخرى ، سيؤدي ذلك إلى تقليل التغييرات في المستودع البعيد إلى حيث تحتفظ برمزك الخاص. عادةً ، ستقوم git pull بعمل git fetch أولاً لتحديث النسخة المحلية من المستودع البعيد ، ثم ستقوم بدمج التغييرات في مستودع الكود الخاص بك وربما نسختك العاملة.

35
Donal

git pull == (git fetch + git merge)

جلب إحضار لا يتغير إلى الفروع المحلية.

إذا كان لديك بالفعل مستودع محلي مع إعداد عن بعد للمشروع المطلوب ، يمكنك الحصول على جميع الفروع والعلامات لجهاز التحكم عن بعد الموجود باستخدام git fetch. ... لا يقوم Fetch بإجراء أي تغييرات على الفروع المحلية ، لذلك ستحتاج إلى دمج فرع بعيد مع فرع محلي مقترن لدمج تغييرات جلب جديدة. من جيثب

33
Iggy

في الواقع Git يحتفظ بنسخة من التعليمات البرمجية الخاصة بك والمستودع البعيد.

الأمر git fetch يجعل نسختك المحلية محدثة عن طريق الحصول على البيانات من مستودع التخزين البعيد. السبب في أننا نحتاج إلى ذلك لأن شخصًا آخر ربما يكون قد أدخل بعض التغييرات على الشفرة وتريد أن تبقي نفسك على اطلاع.

يجلب الأمر git pull التغييرات في المستودع البعيد إلى حيث تحتفظ برمزك الخاص. عادةً ، يقوم git pull بذلك عن طريق إجراء "إحضار إحضار" أولاً لتحديث النسخة المحلية من المستودع البعيد ، ثم يقوم بدمج التغييرات في مستودع الشفرة الخاص بك وربما نسخة العمل الخاصة بك.

32
Pokemon

تحاول أن تكون واضحة وبسيطة.

الأمر git pull هو في الواقع shortcut لـ git fetch متبوعًا ب git merge أو الأمر git rebase الأمر اعتمادًا على التكوين الخاص بك. يمكنك تكوين مستودع Git الخاص بك بحيث يكون git pull جلبًا يتبعه rebase.

31
montells

تمثيل رسومي بسيط للمبتدئين ،

 enter image description here

هنا،

git pull  

سيؤدي إلى جلب رمز من المستودع وإعادة rebase باستخدام بياناتك المحلية ... في git pull ، هناك إمكانية لإنشاء عمليات جديدة.

ولكن في ،

جلب جلب

سيتم جلب الكود من المستودع ونحتاج إلى إعادة تسميته يدويًا باستخدام git rebase

على سبيل المثال: سأحضر من خادم الخادم الرئيسي وأعيد تسميته في رئيسي المحلي.

1) بوابة سحب (rebase ستتم تلقائيا):

git pull Origin master

هنا الأصل هو الريبو البعيد الخاص بك ماجستير هو فرعك

2) إحضار إحضار (تحتاج إلى rebase يدوياً):

git fetch Origin master

سوف تجلب التغييرات خادم من الأصل. وسيكون في منطقتك المحلية حتى تقوم بإعادة تسميته بنفسك. نحن بحاجة إلى إصلاح الصراعات يدويا عن طريق التحقق من الرموز.

git rebase Origin/master

هذا سوف rebase رمز في المحلية. قبل ذلك تأكد من أنك في الفرع الصحيح.

30
Silent Spectator
git pull = git fetch + git merge 
30
Saqib R.

From Pro Git § 2.5 Git Basics - العمل مع أجهزة التحكم عن بعد: الجلب والسحب من أجهزة التحكم عن بعد :

من المهم ملاحظة أن أمر fetch يسحب البيانات إلى مستودعك المحلي - لا يدمجها تلقائيًا مع أي من عملك أو يعدل ما تعمل عليه حاليًا. يجب عليك دمجها يدويًا في عملك عندما تكون جاهزًا.

إذا كان لديك فرع تم إعداده لتتبع فرع بعيد ، فيمكنك استخدام الأمر git pull لجلب فرع من البعد ثم دمجه في الفرع الحالي تلقائيًا. قد يكون هذا سير عمل أسهل أو أكثر راحة لك ؛ افتراضيًا ، يقوم الأمر git clone تلقائيًا بإعداد الفرع الرئيسي المحلي لتتبع الفرع الرئيسي البعيد على الخادم الذي استنسخت منه (على افتراض أن جهاز التحكم عن بعد له فرع رئيسي). يؤدي تشغيل git pull عمومًا إلى جلب البيانات من الخادم الذي استنسخت منه أصلاً ، ويحاول تلقائيًا دمجها في الشفرة التي تعمل عليها حاليًا.

28
Zhenxiao Hao

بوابة السحب

ينفذ وظيفتين باستخدام أمر واحد.

يقوم بإحضار كافة التغييرات التي تم إجراؤها على الفرع البعيد ثم دمج تلك التغييرات في الفرع المحلي الخاص بك. يمكنك أيضًا تعديل سلوك السحب بتمرير --rebase. يمكن قراءة الفرق بين الدمج و rebase هنا

git fetch

إحضار الجلب لا يؤدي إلا نصف عمل السحب. إنه يجلب التغييرات البعيدة إلى الريبو المحلي الخاص بك ولكن لا يطبقها على فروعك. يجب عليك تطبيق هذه التغييرات صراحة. ويمكن القيام بذلك على النحو التالي:

git fetch
git rebase Origin/master
22
Animesh Sharma

يجب أن نضع في اعتبارنا طبيعة بوابة. لديك أجهزة التحكم عن بعد والفروع المحلية الخاصة بك (وليس بالضرورة نفس الشيء). بالمقارنة مع أنظمة التحكم في المصادر الأخرى ، قد يكون هذا الأمر محيرًا بعض الشيء.

عادة عند الخروج من جهاز التحكم عن بعد يتم إنشاء نسخة محلية تتعقب جهاز التحكم عن بعد.

ستعمل git fetch مع الفرع البعيد وتحديث معلوماتك.

هذا هو الحال فعلاً إذا كانت شركات SWE أخرى تعمل في نفس الفرع ، ونادراً ما كانت الحال في سيناريوهات مشروع واحد صغير - فرع واحد - واحد.

لا يزال عملك على الفرع المحلي كما هو. من أجل إحضار التغييرات إلى الفرع المحلي لديك ، عليك دمج/إعادة إدخال التغييرات من الفرع البعيد.

git pull يفعل بالضبط هاتين الخطوتين (أي - rebase لإعادة rebase بدلاً من الدمج)

إذا كان السجل المحلي والتاريخ البعيد بهما صراعان ، فستضطر إلى القيام بالدمج أثناء git Push لنشر تغييراتك.

وبالتالي ، يعتمد الأمر حقًا على طبيعة بيئة العمل الخاصة بك وتجربة ما يجب استخدامه.

22
g24l

من بوابة غش ورقة :

git fetch <remote> // Download all changes from <remote>, but don't integrate into HEAD
git pull <remote> <branch> // Download changes and directly merge/integrate into HEAD
20
Nan Xiao

من ما فهمته ،

Git pull - يسحب لأسفل من جهاز تحكم عن بعد محدد (يحدده المستخدم) وسيقوم بدمجه على الفور في فرع نستخدمه حاليًا. إنها في الأساس مزيج من أوامر Fetch و Merge.

Git Fetch - هو نفسه سحب ، لكنه لن يقوم بأي دمج. حتى تتمكن من مراقبة الملفات بعناية قبل دمجها.

يجب أن يكون عنوان url هذا مفيدًا لمزيد من الفهم: الفرق بين سحب git و fet git و git clone (و rebase git).

16
Pragyaditya Das

بعبارات بسيطة ، إذا كنت على وشك أن تقفز على طائرة بدون إنترنت ... قبل المغادرة ، يمكنك فقط git fetch Origin <master>. سيؤدي ذلك إلى إحضار جميع التغييرات في جهاز الكمبيوتر الخاص بك ، ولكنه يبقيها منفصلة عن مساحة العمل/التنمية المحلية.

على متن الطائرة ، يمكنك إجراء تغييرات على مساحة العمل المحلية الخاصة بك ومن ثم دمجها مع ما جلبته وحل تعارضات الدمج المحتملة دون استخدام الإنترنت. وما لم يقم شخص ما جديد بتغييرات متعارضة على الريبو البعيد ، فبمجرد وصولك إلى الوجهة ، ستفعل git Push Origin <branch> وتذهب للحصول على قهوتك


من هذا أتلاسيان رهيبة البرنامج التعليمي:

يقوم أمر git fetch بتنزيل الملفات ، والملفات ، والمرجعيات من مستودع بعيد إلى الريبو المحلي.

الجلب هو ما تفعله عندما تريد أن ترى ما كان عليه الجميع (آخر). إنه مشابه لتحديث svn لأنه يتيح لك معرفة كيفية تقدم السجل المركزي ، ولكنه لا يجبرك على دمج التغييرات فعليًا في مستودع التخزين الخاص بك. Git عزل المحتوى الذي تم جلبه كمحتوى من المحتوى المحلي الحالي ، له مطلقًا ليس له أي تأثير على أعمال التطوير المحلية الخاصة بك . يجب سحب المحتوى الذي تم جلبه بشكل صريح باستخدام الأمر git checkout. هذا يجعل جلب طريقة آمنة لمراجعة الالتزامات قبل دمجها في مستودعك المحلي.

عند تنزيل محتوى من repo عن بعد ، تتوفر الأوامر git pull و git fetch لإنجاز المهمة. يمكنك اعتبار git fetch الإصدار "الآمن" للأمرين. سيتم تنزيل المحتوى عن بُعد ولكن لن يتم تحديث حالة عمل الريبو المحلي ، مما يترك عملك الحالي دون تغيير. git pull هو البديل الأكثر عدوانية ، وسوف يقوم بتنزيل المحتوى عن بعد للفرع المحلي النشط وتنفيذها على الفور git merge لإنشاء التزام دمج للمحتوى البعيد الجديد. إذا كان لديك تغييرات معلقة قيد التقدم ، فسيؤدي ذلك إلى حدوث تعارضات وتدفق دقة حل التعارض.


مع git pull:

  • أنت لا تحصل على أي عزلة.
  • يؤثر على التنمية المحلية الخاصة بك.
  • لا يلزم أن يتم سحبه بشكل صريح. لأنه يقوم ضمنيًا بـ git merge.
  • انها في الأساس ليست آمنة. انها عدوانية.
  • على عكس git fetch ، حيث يؤثر فقط على .git/refs/remotes ، ستؤثر git pull على كل من .git/refs/remotes و .git/refs/heads/

هممم ... لذلك إذا لم أقوم بتحديث نسخة العمل باستخدام git fetch ، فأين أقوم بإجراء التغييرات؟ أين git جلب جلب المخالفات الجديدة؟

سؤال رائع يضعها في مكان ما معزولة عن نسخة عملك. لكن مرة أخرى أين؟ هيا نكتشف.

في دليل مشروعك (على سبيل المثال ، أين يمكنك تنفيذ أوامر gitname__):

  1. lsname__. هذا سيظهر الملفات والدلائل. لا شيء رائع ، وأنا أعلم.

  2. افعل الآن ls -a. سيؤدي هذا إلى إظهار نقطة الملفات أي الملفات التي تبدأ بـ . ستتمكن حينئذٍ من رؤية دليل باسم: .git.

  3. افعل cd .git. سيؤدي هذا بوضوح إلى تغيير الدليل الخاص بك.
  4. الآن يأتي الجزء الممتع ؛ افعل lsname__. سترى قائمة الدلائل. نحن نبحث عن refsname__. افعل cd refs.
  5. من المثير للاهتمام معرفة ما يوجد داخل جميع الأدلة ، ولكن دعونا نركز على اثنين منهم. headsو remotesname__. استخدم cdللتحقق من داخلها أيضًا.
  6. أي git fetch ستقوم بتحديث العناصر الموجودة في دليل /.git/refs/remotes. لن يتم تحديث أي شيء في دليل /.git/refs/heads.
  7. سيقوم أي git pull أولاً بإجراء git fetch ، وتحديث العناصر في دليل /.git/refs/remotes ، ثم دمج مع المحلي الخاص بك ومن ثم تغيير الرأس داخل الدليل /.git/refs/heads.

يمكن أيضًا العثور على إجابة جيدة ذات صلة أين يضع "git fetch" نفسه؟

ابحث أيضًا عن "تدوين Slash" من اصطلاحات تسمية الفرع Git post.

8
Honey

بعبارات قصيرة وبسيطة:

git fetch: انظر إذا كانت هناك أشياء جديدة.

git pull: خذ الأشياء الجديدة ووضعها على رأس الأشياء الخاصة بك.

8
miva2

Git Fetch

يساعدك على التعرف على آخر التحديثات من git repository. لنفترض أنك تعمل في فريق يستخدم GitFlow ، حيث يعمل الفريق على branches (ميزات). باستخدام git fetch --allcommand ، يمكنك التعرف على كل branches الجديد داخل repository.

غالبًا git fetch يُستخدم مع git reset. على سبيل المثال ، تريد إعادة كل تغييراتك المحلية إلى حالة المخزون الحالية.

git fetch --all // get known about latest updates
git reset --hard Origin/[branch] // revert to current branch state

بوابة السحب

يقوم هذا الأمر بتحديث branch مع الحالة الحالية repositorybranch. دعنا نستمر مع GitFlow. ميزة متعددة branches كانت merged إلى develop الفرع وعندما تريد تطوير ميزات جديدة للمشروع ، يجب عليك الانتقال إلى التطوير branch والقيام بـ git pull للحصول على الحالة الحالية لـ developbranch

وثائق لـ GitFlow https://Gist.github.com/peterdeweese/4251497

3
Andrei Todorut

أعتقد أن معظم الإجابات أجاب على الفرق بشكل جيد. وأود أن أؤكد على عند استخدام أي بدلا من ذلك.

 Enter image description here

يمكن أن يكون الجلب مفيدًا عندما تحتاج إلى الحصول على تحديث المطورين الآخرين ، لكنك ترغب في مواصلة عملك دون عائق. يستخدم الأشخاص الذين غالبًا ما يرغبون في عدم الاتصال بالإنترنت والعمل fetch للحصول على آخر التحديثات حتى يكون متصلاً. في وقت لاحق عندما يكون/هو مرتاحًا لتغييراتها ، قم بدمج التغييرات من الفرع في مساحة عمله.

في حين أن الأشخاص الذين يعملون عبر الإنترنت والذين يثقون في تغييراتهم ويريدون الحصول على أحدث رمز و merge مباشرة يستخدم pull. نادراً ما أستخدم fetch لأنه للتحقق من آخر التحديثات ، أتحقق منها عبر موقع GitHub وأعمل دائمًا في وضع عدم الاتصال. كما ذكرت قد يكون لديك استخدام للسيناريو أعلاه.

3
ishandutta2007

يقوم Git fetch بمزامنة كتالوج المستودع عن بعد مع حسابك المحلي. لن يتم دمج تغييرات الملف/الرمز من بعيد إلى فرعك المحلي.

Git pull يقوم بتنزيل التغييرات المتعلقة بفرعك المحلي الحالي ثم دمجها.

1
Arnel Lenteria