Які відмінності між git pullі git fetch?

Простіше кажучи, git pullчи git fetchслідує a git merge.

Ви можете зробити в git fetchбудь-який час, щоб оновити свої відділення віддаленого відстеження під refs/remotes/<remote>/.

Ця операція ніколи не змінює будь-які ваші власні місцеві відділення під refs/heads, і це безпечно робити без зміни вашої робочої копії. Я навіть чув про людей, які git fetchперіодично виконують роботу з кроном у фоновому режимі (хоча я б не рекомендував це робити).

A git pull- це те, що ви зробите для того, щоб оновити локальну гілку з її віддаленою версією, а також оновити інші гілки віддаленого відстеження.

Документація Git - git pull :

У режимі за замовчуванням git pullце стенограма, за git fetchякою слід git merge FETCH_HEAD.

• Під час використання pullGit намагається автоматично зробити вашу роботу за вас. Це залежно від контексту , тому Git об'єднає будь-які витягнуті комісії у гілку, в якій ви зараз працюєте. pull Автоматично об’єднує комісії, не даючи вам спочатку їх переглянути . Якщо ви не дуже близько керуєте своїми філіями, у вас можуть виникнути часті конфлікти.

• Коли ви fetch, Git збирає будь-які комісії з цільової гілки, які не існують у вашому поточному відділенні, і зберігає їх у вашому локальному сховищі . Однак це не об'єднує їх із вашою нинішньою галуззю . Це особливо корисно, якщо вам потрібно постійно оновлювати сховище, але ви працюєте над тим, що може зламатися, якщо ви оновите свої файли. Щоб інтегрувати коміти у свою головну галузь, ви використовуєте merge.

Важливо порівнювати філософію дизайну git з філософією більш традиційного інструменту управління джерелами, як SVN.

Subversion була розроблена та побудована за моделлю клієнт / сервер. Є одне сховище, яке є сервером, і кілька клієнтів можуть отримати код з сервера, попрацювати на ньому, а потім зробити його назад на сервер. Припущення полягає в тому, що клієнт завжди може звернутися до сервера, коли йому потрібно виконати операцію.

Git був розроблений для підтримки більш розповсюдженої моделі без потреби в центральному сховищі (хоча ви, звичайно, можете скористатися нею, якщо вам подобається). Також 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у вашому локальному господарстві є філія.

Коли ви клонуєте сховище, ви отримуєте весь сховище для вашого локального хоста. Це означає, що на той час у вас є початковий / головний вказівник на HEADта головний вказівник на те саме HEAD.

коли ви почнете працювати і виконувати зобов’язання, ви пересунете головний вказівник на HEAD+ ваші коміти. Але вказівник початок / головний все ще вказує на те, що було під час клонування.

Отже різниця буде:

• Якщо ви зробите git fetchце, ви просто отримаєте всі зміни у віддаленому сховищі ( GitHub ) і перемістіть початковий / головний вказівник на HEAD. Тим часом ваш місцевий майстер відділення буде постійно вказувати, де він є.
• Якщо ви зробите це git pull, воно в основному вийде (як було пояснено раніше) і об'єднає будь-які нові зміни у вашу головну гілку та перемістить вказівник на HEAD.

Іноді допомагає візуальне уявлення.

Коротко

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) - Майк Пірс

і кришки git pull, git fetch, git cloneі git rebase.

====

ОНОВЛЕННЯ

Я думав би оновити це, щоб показати, як ви насправді використовуєте це на практиці.

1. Оновіть локальне репо з дистанційного (але не зливайтеся):

   git fetch 
   

2. Завантаживши оновлення, давайте подивимося на відмінності:

   git diff master origin/master 
   

3. Якщо ви задоволені цими оновленнями, тоді об'єднайте:

   git pull
   

Примітки:

На кроці 2: Докладніше про відмінності між локальним та віддаленим див. У розділі: Як порівняти локальну гілку git із віддаленою гілкою?

На кроці 3: Мабуть, точніше (наприклад, на репо, що швидко змінюється) зробити 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.

Зверніть увагу, що ви можете використовувати. (поточний каталог) як <репозиторій>, який потрібно витягнути
з локального сховища - це корисно при об'єднанні локальних гілок 
в поточну галузь.

Також зауважте, що варіанти, призначені для самої git-pull та основи git-merge 
необхідно надати перед параметрами, призначеними для git-fetch.

Ви б потягнули, якщо хочете, щоб історії злилися, ви б прийшли, якщо просто "хочете кодек", як хтось позначав тут статті.

Ви можете отримати з віддаленого сховища, побачити відмінності, а потім витягнути або об'єднати.

Це приклад віддаленого сховища, що називається, originі гілки під назвою masterвідстеження віддаленої гілки origin/master:

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

Коротка і проста відповідь - git pullце просто git fetchслідування git 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 fetch

Він завантажить усі реф і об’єкти та будь-які нові відділення у ваш локальний сховище ...

Вилучення гілок та / або тегів (разом "refs") з одного або декількох інших сховищ, а також об'єктів, необхідних для завершення їх історії. Гілки віддаленого відстеження оновлюються (див. Опис нижче щодо способів контролю такої поведінки).

За замовчуванням також отримується будь-який тег, який вказує на витягнуті історії; ефект полягає в тому, щоб отримати теги, які вказують на гілки, які вас цікавлять. Цю поведінку за замовчуванням можна змінити, скориставшись параметрами --tags або --no-tags або налаштувавши віддалений..tagOpt. Використовуючи refspec, який чітко отримує теги, ви можете отримати теги, які також не вказують на гілки, які вас цікавлять.

git fetch може отримувати або з одного названого сховища, або з URL-адреси, або з декількох сховищ одразу, якщо вказано та є віддалені. запис у файл конфігурації. (Див. Git-config 1 ).

Якщо не вказано пульт дистанційного керування, за замовчуванням буде використовуватися віддалений вихідний код, якщо немає поточної гілки, налаштованої вище.

Імена отриманих посилань разом із іменами об'єктів, на які вони вказують, записуються у .git / FETCH_HEAD. Ця інформація може використовуватися скриптами або іншими командами git, такими як git-pull.

git pull

Він застосує зміни від віддаленого до поточної гілки в локальному ...

Включає зміни з віддаленого сховища в поточну гілку. У режимі за замовчуванням git pull є скороченням для git fetch з подальшим об'єднанням git FETCH_HEAD.

Точніше, git pull запускає git fetch із заданими параметрами і викликає git merge для об'єднання отриманих головок гілок у поточну гілку. З --rebase, він запускає git rebase замість git spajanje.

має бути назвою віддаленого сховища, переданого 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

Ця вище команда - найкорисніша команда в моєму житті git, яка зекономила багато часу.

Перш ніж натиснути на сервер свої нові зобов’язання, спробуйте цю команду, і вона автоматично синхронізує останні зміни на сервері (з вилученням і злиттям) і поставить ваші зобов’язання вгорі в журналі git. Не потрібно турбуватися про ручне потягування / злиття.

Деталі можна знайти на веб- сайті: 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.

Деякі основні переваги наявності дзеркала дистанційного керування:

• Продуктивність (прокручуйте всі коміти та повідомлення, не намагаючись видавити їх через мережу)
• Відгук про стан вашого місцевого репо (наприклад, я використовую SourceTree Atlassian, який дасть мені лампочку із зазначенням, чи я рухаюся вперед чи позаду порівняно з походженням. Цю інформацію можна оновити за допомогою GIT FETCH).

Я також боровся з цим. Насправді я потрапив сюди з пошуком Google саме того самого питання. Прочитавши всі ці відповіді, нарешті намалював картину в моїй голові, і я вирішив спробувати збити це, дивлячись на стан 2 сховищ та 1 пісочниці та дій, що виконуються з часом під час перегляду їх версії. Тож ось що я придумав. Будь ласка, виправте мене, якщо я кудись заплутався.

Три репости з результатом:

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

Три репости з потягом

---------------------     -----------------------     -----------------------
- 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 застосує зміни, отримані у вашому сховищі або відділенні.

Тож тепер Ви можете ретельно контролювати файли, перш ніж об'єднати їх у свій сховище. Ви також можете змінити, Dякщо потрібно, через змінену C.

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 просить у віддаленого РЕПО всіх зобов’язань, які зробили інші, але у вас немає місцевого репо. Отримати завантаження цих комісій та додавання їх до локального сховища.

Git Merge

Ви можете застосувати зміни, завантажені через виборку, за допомогою команди злиття. Злиття візьме комісії, отримані з завантаження, і спробує додати їх до вашої місцевої філії. Злиття збереже історію фіксації ваших локальних змін, так що коли ви поділитесь вашою філією із натисканням, Git дізнається, як інші можуть об’єднати ваші зміни.

Git Pull

Вилучення та злиття виконуються разом досить часто, щоб була створена команда, що поєднує в собі два, тягнути. Потягніть виконує завантаження, а потім об'єднання для додавання завантажених комісій у вашу локальну філію.

Єдина різниця між git pullі git fetchполягає в тому, що:

git pull тягне з віддаленої гілки і зливає її.

git fetch виймається лише з віддаленої гілки, але вона не зливається

тобто git pull = git fetch + git merge ...

Простіше кажучи, якщо ви збиралися скокнути на літак без будь-якого з’єднання з Інтернетом ... перед від'їздом ви могли просто зробити git fetch origin <master>. Це дозволило б отримати всі зміни на вашому комп'ютері, але тримайте його окремо від локальної розробки / робочої області.

У площині ви можете внести зміни до місцевого робочого простору, а потім об'єднати його з тим, що ви отримали, і вирішити потенційні конфлікти злиття, без підключення до Інтернету. І якщо хто - то не зробили нові зміни конфліктуючих в віддалене сховище , то після прибуття в пункті призначення ви могли б зробити git push origin <branch>і піти отримати кави.

З цього дивовижного підручника з атласу :

У 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 fetch зберігає нові зобов’язання?

Чудове запитання. Він розміщує його десь ізольовано від вашої робочої копії. Але знову ж де? Давай дізнаємось.

У каталозі вашого проекту (тобто, де ви виконуєте свої gitкоманди) виконайте:

1. ls. Це покаже файли та каталоги. Нічого крутого, я знаю.

2. Тепер зробіть ls -a. Це покаже точкові файли , тобто файли , що починаються з .ви потім зможете побачити каталог з ім'ям: .git.

3. Зробіть cd .git. Це, очевидно, змінить ваш каталог.
4. Тепер приходить весела частина; робити ls. Ви побачите список каталогів. Ми шукаємо refs. Зробіть cd refs.
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"? .

Крім того, шукайте "Slash notation" з гілки 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то ваш місцевий git не знав би, що додано 2 коміти. І це просто сказало б:

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

Але це застаріло і неправильно. Це тому, що git надасть вам відгук виключно на основі того, що він знає. Це не забуває про нові зобов'язання, які ще не знищили ...

Чи є можливість побачити нові зміни, внесені у віддалений під час роботи на філії локально?

Деякі IDE (наприклад, Xcode) є надзвичайно розумними та використовують результат a git fetchі можуть коментувати рядки коду, які були змінені у віддаленому відділенні поточної робочої гілки. Якщо цей рядок було змінено як локальними змінами, так і віддаленою гілкою, то цей рядок буде помічено червоним кольором. Це не конфлікт злиття. Це потенційний конфлікт злиття. Це заголовок, який можна використовувати для вирішення майбутнього конфлікту злиття, перш ніж робити git pullз віддаленої гілки.

Прикольна порада:

Якщо ви отримали віддалену гілку, наприклад, зробили:

git fetch origin feature/123

Тоді це перейде у ваш віддалений каталог. Він все ще не доступний у вашому локальному каталозі. Однак це спрощує реєстрацію до цієї віддаленої гілки за допомогою DWIM (Робіть, що я маю на увазі):

git checkout feature/123

вам більше не потрібно робити:

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

Більше про це читайте тут

Git дозволяє застосовувати хронологічно старі коміти після новіших доручень. Через це акт передачі комісій між сховищами розбивається на два етапи:

1. Копіювання нових комісій з віддаленого відділення в копію цієї віддаленої гілки всередині локального репо.

   (репо до операції репо) master@remote >> remote/origin/master@local

2. Інтеграція нових комісій до місцевого відділення

   (внутрішня операція репо) 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 підтримує не лише ваше локальне сховище, але він також підтримує локальну копію віддаленого сховища.

git fetchоновлює вашу локальну копію віддаленого сховища. Наприклад, якщо у вашому віддаленому сховищі є GitHub - можливо, ви захочете внести будь-які зміни, внесені до віддаленого сховища, у вашу локальну копію віддаленого сховища. Це дозволить вам виконувати такі операції, як порівняння або злиття.

git pullз іншого боку, приведе зміни у віддаленому сховищі, де ви зберігаєте власний код. Як правило, спочатку git pullзробіть git fetchактуальну локальну копію віддаленого сховища, а потім об'єднає зміни у ваше власне сховище коду та, можливо, вашу робочу копію.

git pull == (git fetch + git merge)

git fetch не змінюється на місцеві гілки.

Якщо у вас вже є локальне сховище з віддаленим налаштуванням для потрібного проекту, ви можете схопити всі гілки та теги для існуючого віддаленого за допомогою git fetch. ... Вибір не вносить жодних змін до місцевих гілок, тому вам потрібно буде об'єднати віддалену гілку з парною локальною гілкою, щоб включити нові зміни. з github

Намагаючись бути зрозумілим і простим.

Команда git pull - це фактично shortcutдля git fetch, за яким слідує git merge або команда gbase rebase, залежно від вашої конфігурації. Ви можете налаштувати своє сховище Git таким чином, щоб git pull був результатом, за яким слідує повторна база даних.

Просте графічне зображення для початківців,

тут,

git pull  

вилучить код із сховища та перезавантажить ваш локальний ... у git pull існує можливість створення нових комітетів.

але в,

git fetch

вилучить код із сховища, і нам потрібно відновити його вручну, використовуючи git rebase

наприклад: я збираюся взяти з майстра сервера і відновити його в моєму локальному майстрі.

1) git pull (перезавантаження буде виконано автоматично):

git pull origin master

тут походження - ваш віддалений майстер репо - ваша філія

2) git fetch (потрібно перезавантажити вручну):

git fetch origin master

він отримає зміни сервера від походження. і він буде знаходитись у вашому регіоні, поки ви не переобладнаєте його самостійно. нам потрібно виправляти конфлікти вручну, перевіряючи коди.

git rebase origin/master

це перейме код на локальний. перед цим переконайтеся, що ви в правій галузі.

Насправді Git підтримує копію власного коду та віддаленого сховища.

Команда git fetchоновлює локальну копію, отримуючи дані з віддаленого сховища. Тому нам це потрібно через те, що хтось інший, можливо, вніс деякі зміни в код, і ви хочете постійно оновлювати себе.

Команда git pullвносить зміни у віддалене сховище туди, де ви зберігаєте власний код. Як правило, git pullце робить, роблячи "git fetch", щоб спочатку оновити локальну копію віддаленого сховища, а потім об'єднує зміни у ваше власне сховище коду та, можливо, у вашу робочу копію.