В чем разница между "git pull" и "git fetch"?


Модератор, Обратите Внимание: учитывая, что этот вопрос уже был шестьдесят шесть ответов отправлено на него, подумайте, являетесь ли вы внося что-нибудь новое перед отправкой другой.

В чем разница между git pull и git fetch?

30   10366  

30 ответов:

в самых простых выражениях,git pull тут git fetch затем git merge.

можно сделать git fetch в любое время, чтобы обновить ветви удаленного отслеживания под refs/remotes/<remote>/.

эта операция никогда не изменяет ни один из ваших собственных локальных филиалов под refs/heads, и безопасно сделать без изменения вашей рабочей копии. Я даже слышал о бегущих людях git fetch периодически в задании cron в фоновом режиме (хотя я бы не рекомендовал это делать).

A git pull это то, что вы сделали бы, чтобы обновить локальную ветвь с ее удаленной версией, а также обновить другие ветви удаленного отслеживания.

документация ГИТ: git pull

  • при использовании pull, Git пытается автоматически выполнять вашу работу за вас. это контекстно-зависимая, так что Git объединит все вытащенные коммиты в ветку, в которой вы сейчас работаете. pullавтоматически объединяет коммиты, не позволяя вам просматривать их в первую очередь. Если вы не будете тесно управлять своими филиалами, вы можете столкнуться с частыми конфликтами.

  • когда вы fetch, Git собирает любые коммиты от цели ветви, которые не существуют в вашей текущей ветви и хранит их в локальном репозитории. Однако,он не объединяет их с вашей текущей веткой. Это особенно полезно, если вам нужно поддерживать свой репозиторий в актуальном состоянии, но вы работаете над чем-то, что может сломаться, если вы обновите свои файлы. Чтобы интегрировать коммиты в свою главную ветвь, вы используете merge.

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

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

git был предназначен для поддержки более распределенной модели без необходимости в Центральном репозитории (хотя вы можете использовать его, если хотите). Также git был разработан таким образом, что клиент и сервер не должны быть онлайн одновременно. Git был разработан таким образом, чтобы люди по ненадежной ссылке могли обмениваться кодом по электронной почте, даже. Можно работать полностью отключенным и записать компакт-диск для обмена кодом через git.

для поддержки этой модели git поддерживает локальный репозиторий с ваш код, а также дополнительный локальный репозиторий, который отражает состояние удаленного репозитория. Сохраняя копию удаленного репозитория локально, git может определить необходимые изменения, даже если удаленный репозиторий недоступен. Позже, когда вам нужно отправить изменения кому-то еще, git может передать их в виде набора изменений с момента времени, известного удаленному репозиторию.

  • git fetch - это команда, которая говорит: "Принесите мой местный копию удаленного репозитория в актуальном состоянии."

  • git pull говорит: "внесите изменения в удаленный репозиторий, где я храню свой собственный код."

обычно git pull этого делать git fetch чтобы обновить локальную копию удаленного репозитория, а затем объединить изменения в свой собственный репозиторий кода и, возможно, вашу рабочую копию.

забрать, чтобы сохранить в виду, что там часто хотя бы трех экземплярах проекта на вашей рабочей станции. Одна копия-это ваш собственный репозиторий с собственной историей фиксации. Вторая копия-это ваша рабочая копия, в которой вы редактируете и строите. Третья копия-это ваша локальная "кэшированная" копия удаленного репозитория.

здесь Оливер Стил образ того, как все это все сочетается:

enter image description here

Если есть достаточный интерес, я полагаю, что я мог бы обновить изображение, чтобы добавить git clone и git merge...

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

git fetch
git diff ...origin

мне стоило немного понять, в чем была разница, но это простое объяснение. master в вашем localhost есть филиал.

при клонировании репозитория вы получаете весь репозиторий на локальный хост. Это означает, что в это время у вас есть указатель origin/master на HEAD и мастер указывает на то же самое HEAD.

когда вы начинаете работать и делаете коммиты, вы продвигаете главный указатель на HEAD + ваши коммиты. Но происхождение / мастер указатель по-прежнему указывает на то, что это было, когда вы клонировали.

так что разница будет:

  • если вы git fetch Он просто получит все изменения в удаленном репозитории (GitHub) и переместите указатель origin / master на HEAD. Тем временем ваш местный мастер филиала будет продолжать указывать, где он есть.
  • если вы git pull, он будет делать в основном выборку (как объяснялось ранее) и объединять любые новые изменения в вашей главной ветви и переместите указатель на HEAD.

иногда визуальное представление помогает.

enter image description here

коротко

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 здесь. Смотри @Джастин Ом комментарий в другом ответе.

Смотрите также:http://longair.net/blog/2009/04/16/git-fetch-and-merge/

git-pull - Fetch from and merge with another repository or a local branch
SYNOPSIS

git pull   …
DESCRIPTION

Runs git-fetch with the given parameters, and calls git-merge to merge the 
retrieved head(s) into the current branch. With --rebase, calls git-rebase 
instead of git-merge.

Note that you can use . (current directory) as the <repository> to pull 
from the local repository — this is useful when merging local branches 
into the current branch.

Also note that options meant for git-pull itself and underlying git-merge 
must be given before the options meant for 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) внимательно.

бонус:

говоря о pull & fetch в приведенных выше ответах, я хотел бы поделиться интересным трюком,

git pull --rebase

эта команда выше является самой полезной командой в моей жизни git, которая сэкономила много времени.

прежде чем нажимать новые коммиты на сервер, попробуйте эту команду, и она автоматически синхронизирует последние изменения сервера (с помощью fetch + merge) и разместит вашу фиксацию вверху в журнале git. Не нужно беспокоиться о ручном вытягивании / слиянии.

найти подробную информацию по адресу:http://gitolite.com/git-pull--rebase

enter image description here

это интерактивное графическое представление очень полезно для понимания git:http://ndpsoftware.com/git-cheatsheet.html

git fetch просто "загружает" изменения из удаленного в локальный репозиторий. git pull загружает изменения и объединяет их в текущую ветку. "В режиме по умолчанию, git pull - это сокращение от git fetch следовал по git merge FETCH_HEAD."

Я хотел бы иметь некоторое визуальное представление о ситуации, чтобы понять эти вещи. Возможно, другие разработчики тоже хотели бы это увидеть, так что вот мое дополнение. Я не совсем уверен, что все это правильно, поэтому, пожалуйста, прокомментируйте, если вы обнаружите какие-либо ошибки.

                                         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).

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

git fetch

он будет загружать все refs и объекты и любые новые ветви в локальном репозитории...

извлечение ветвей и / или тегов (совместно, "ссылки") из одного или нескольких другие репозитории, а также объекты, необходимые для их завершения истории. Ветви удаленного отслеживания обновляются (см. Описание ниже приведены способы управления этим поведением).

по умолчанию любой тег, который указывает на извлекаемые истории, является также извлекается; эффект заключается в извлечении тегов ссылки на ветки которые вас это интересует. Это поведение по умолчанию можно изменить с помощью теги или-нет-теги настройках или настройка дистанционный..тагопт. С помощью refspec, который явно извлекает теги, вы можете извлечь теги, которые не указывают на интересующие вас ветви в том числе.

git fetch может извлекать из одного именованного репозитория или URL-адреса, или из нескольких репозиториев сразу, если и есть дистанционное управление. запись в конфигурации файл. (См. git-config1).

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

имена ссылок, которые извлекаются вместе с именами объектов на них указывают, на них пишут .git / FETCH_HEAD. Эта информация может быть используется скриптами или другими командами git, такими как git-pull.


git тяни

он будет применять изменения от remote до текущая филиала на местном языке...

включает в себя изменения из удаленного репозитория в текущую ветку. В своем режиме по умолчанию git pull является сокращением для git fetch, за которым следует git merge FETCH_HEAD.

точнее, git pull запускает git fetch с заданными параметрами и вызывает git merge для объединения извлеченных головок ветвей в текущую отделение. С --перебазировать, он работает с Git перебазирования вместо git слияние.

должно быть имя удаленного репозитория, передаваемые git-fetch1. можно назвать произвольный удаленный ref (например, имя тега) или даже коллекция ссылок с соответствующими дистанционное отслеживание филиалов (например, refs / heads/: refs / remotes / origin/), но обычно это имя ветки в удаленном репозитории.

значения по умолчанию для и чтения этот конфигурация" remote "и" merge " для текущей ветви, заданная git-branch --трек.


Я также создать визуальный ниже, чтобы показать вам как git fetch и git pull работаем вместе...

git pull and 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 можно объяснить следующим сценарием: (имея в виду, что фотографии говорят громче, чем слова!, Я предоставил графическое представление)

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

так, Начальное Состояние из двух ветвей, когда вы разветвляли основной проект на вашем локальном репозитории, будет так - (A,B и C модули уже завершены проекта)

enter image description here

Итак, вы начали работать над новым модулем (допустим D) и когда вы закончили D модуль, который вы хотите нажать к основной ветке, но пока что происходит то, что один из ваших товарищей по команде разработал новый модуль E,F и изменен C.
Итак, теперь произошло то, что ваш локальный репозиторий отсутствует за первоначальным прогрессом проекта и, таким образом, нажатие ваших изменений на главную ветвь может привести к конфликту и может вызвать ваш модуль D неисправность.

enter image description here

чтобы избежать таких проблем и работать параллельно с первоначальный прогресс проекта их два пути:

1. Git Fetch - это загрузит все изменения, которые были внесены в проект origin/main branch, которые не присутствуют в вашем локальном филиале. И будет ждать, пока команда git Merge применит изменения, которые были извлечены в ваш репозиторий или ветку.

enter image description here

так что теперь вы можете тщательно контролировать файлы, прежде чем объединить его с вашим хранилище. И вы также можете изменить D Если требуется из-за измененного C.

enter image description here

2. Git Pull - это обновит вашу локальную ветвь с исходной / главной ветвью, т. е. фактически то, что она делает, - это комбинация git Fetch и git merge друг за другом. но это может привести к конфликтам, поэтому рекомендуется использовать git Pull с чистым копировать.

enter image description here

мы просто говорим:

git pull == git fetch + git merge

если вы запустите git pull, вам не нужно объединять данные в локальные. Если вы запустите git fetch, это означает, что вы должны работать git merge для получения последнего кода на локальную машину. В противном случае локальный машинный код не будет изменен без слияния.

так что в графическом интерфейсе Git, когда вы делаете выборку, вы должны объединить данные. Fetch не будет вносить изменения в код на вашем локальном компьютере. Вы можете проверить это при обновлении кода путем выборки один раз принести и видите, код он не изменит. Затем вы сливаетесь... Вы увидите измененный код.

git fetch переносит код с удаленного сервера в ветви отслеживания в локальном репозитории. Если ваш пульт дистанционного управления называется origin (по умолчанию) тогда эти ветви будут в пределах origin/, например origin/master,origin/mybranch-123 и т. д. Это не ваши текущие ветви, они local копии этих ветвей с сервера.

git pull тут git fetch а то и объединяет код из ветки отслеживания в текущий локальный код версия этой ветки. Если вы еще не готовы к этим изменениям, просто git fetch первый.

git fetch будет получать удаленные ветви, так что вы можете git diff или git merge их с текущей веткой. git pull будет выполняться выборка на удаленном brach отслеживается текущей ветви, а затем объединить результат. Вы можете использовать git fetch чтобы узнать, есть ли какие-либо обновления для удаленной ветви без необходимости их слияния с локальной ветвью.

Git Fetch

вы загружаете изменения в свою локальную ветвь из источника через fetch. Fetch запрашивает удаленное РЕПО для всех коммитов, которые сделали другие, но у вас нет на вашем локальном РЕПО. Fetch загружает эти коммиты и добавляет их в локальный репозиторий.

Git Merge

вы можете применить изменения, загруженные через fetch с помощью команды merge. Слияние будет принимать коммиты полученные от выборки, и пытаться добавить их в ваш местный филиал. Слияние сохранит историю фиксации ваших локальных изменений, так что, когда вы делитесь своей веткой с push, Git будет знать, как другие могут объединить ваши изменения.

Git Pull

Fetch и merge запускаются вместе достаточно часто, чтобы была создана команда, которая объединяет два, pull. Pull выполняет выборку, а затем слияние, чтобы добавить загруженные коммиты в локальную ветвь.

единственная разница между git pull и git fetch это :

git pull тянет из удаленной ветви и сливает его.

git fetch только извлекает из удаленной ветви, но она не сливается

т. е. git pull = git fetch + git merge ...

Git позволяет применять хронологически более старые коммиты после новых коммитов. Из-за этого акт передачи коммитов между репозиториями разбивается на два этапа:

  1. копировать новые коммиты из удаленного филиала, чтобы скопировать удаленный филиал в локальной РЕПО.

    (РЕПО операция РЕПО) [email protected] >> remote/origin/[email protected]

  2. интеграция новых коммитов в локальную ветку

    (внутри-РЕПО операции) remote/origin/[email protected] >> [email protected]

есть два способа сделать шаг 2. Вы можете:

  1. Fork local branch после последнего общего предка и добавления новых коммитов параллельно коммитам, которые уникальны для локального репозитория, завершается слиянием коммитов, закрывая вилку.
  2. вставить новые коммиты после последнего общего предка и повторно совершает уникальный для локального репозитория.

на git терминология, Шаг 1-это git fetch, Шаг 2 git merge или git rebase

git pull и git fetch и git merge

в чем разница между git pull и git fetch?

чтобы понять это, вам сначала нужно понять, что ваш локальный git поддерживает не только ваш локальный репозиторий, но и локальную копию удаленного репозитория.

git fetch обновляет локальную копию удаленного репозитория. Например, если ваш удаленный репозиторий является GitHub - вы можете извлечь любые изменения, внесенные в удаленный репозиторий, в свою локальную копию удаленный репозиторий. Это позволит вам выполнять такие операции, как сравнение или слияния.

git pull с другой стороны будет сбить изменения в удаленном репозитории, где вы держите свой собственный код. Как правило, git pull будет git fetch сначала обновите локальную копию удаленного репозитория, а затем она объединит изменения в вашем собственном репозитории кода и, возможно, в вашей рабочей копии.

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 merge)

git fetch не изменяет локальные ветви.

Если у вас уже есть локальный репозиторий с удаленной настройкой для нужного проекта, вы можете захватить все ветви и теги для существующего удаленного с помощью git fetch . ... Fetch не вносит никаких изменений в локальные ветви, поэтому вам нужно будет объединить удаленную ветвь с парной локальной ветвью, чтобы включить новые изменения выборки. от github

пытаясь быть ясным и простым.

на git pull

на самом деле Git поддерживает копию вашего собственного кода и удаленный репозиторий.

команда git fetch делает вашу локальную копию актуальной, получая данные из удаленного репозитория. Причина, по которой нам это нужно, заключается в том, что кто-то другой, возможно, внес некоторые изменения в код, и вы хотите, чтобы держать себя в курсе.

команда git pull приносит изменения в удаленном репозитории, где вы храните свой собственный код. Обычно,git pull делает это, делая ' git fetch’ сначала необходимо обновить локальную копию удаленного репозитория, а затем объединить изменения в свой собственный репозиторий кода и, возможно, в рабочую копию.

git pull = git fetch + git merge 

простое графическое представление для новичков,

enter image description here

здесь

git pull  

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

но ,

git fetch

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

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

1) git pull ( rebase будет сделано автоматически):

git pull origin master

здесь происхождения это ваше удаленное РЕПО мастер ваш филиал

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

git fetch origin master

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

git rebase origin/master

это будет перебазировать код в локальный. перед этим убедитесь, что вы находитесь в правильной ветке.