В чем разница между "git pull" и "git fetch"?
Модератор, Обратите Внимание: учитывая, что этот вопрос уже был шестьдесят шесть ответов отправлено на него, подумайте, являетесь ли вы внося что-нибудь новое перед отправкой другой.
В чем разница между git pull
и git fetch
?
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
чтобы обновить локальную копию удаленного репозитория, а затем объединить изменения в свой собственный репозиторий кода и, возможно, вашу рабочую копию.забрать, чтобы сохранить в виду, что там часто хотя бы трех экземплярах проекта на вашей рабочей станции. Одна копия-это ваш собственный репозиторий с собственной историей фиксации. Вторая копия-это ваша рабочая копия, в которой вы редактируете и строите. Третья копия-это ваша локальная "кэшированная" копия удаленного репозитория.
здесь Оливер Стил образ того, как все это все сочетается:
Если есть достаточный интерес, я полагаю, что я мог бы обновить изображение, чтобы добавить
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
.
коротко
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
.====
обновление
я думал, что обновлю это, чтобы показать, как вы на самом деле используете это на практике.
обновите локальное РЕПО с пульта дистанционного управления (но не объединяйте):
git fetch
после загрузки обновлений, давайте посмотрим различия:
git diff master origin / master
если вы довольны этими обновлениями, то объединить:
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
это интерактивное графическое представление очень полезно для понимания 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
работаем вместе...
Я тоже боролся с этим. На самом деле я попал сюда с поиском 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
модули уже завершены проекта)Итак, вы начали работать над новым модулем (допустим
D
) и когда вы закончилиD
модуль, который вы хотите нажать к основной ветке, но пока что происходит то, что один из ваших товарищей по команде разработал новый модульE
,F
и измененC
.
Итак, теперь произошло то, что ваш локальный репозиторий отсутствует за первоначальным прогрессом проекта и, таким образом, нажатие ваших изменений на главную ветвь может привести к конфликту и может вызвать ваш модульD
неисправность.чтобы избежать таких проблем и работать параллельно с первоначальный прогресс проекта их два пути:
1. Git Fetch - это загрузит все изменения, которые были внесены в проект origin/main branch, которые не присутствуют в вашем локальном филиале. И будет ждать, пока команда git Merge применит изменения, которые были извлечены в ваш репозиторий или ветку.
так что теперь вы можете тщательно контролировать файлы, прежде чем объединить его с вашим хранилище. И вы также можете изменить
D
Если требуется из-за измененногоC
.2. Git Pull - это обновит вашу локальную ветвь с исходной / главной ветвью, т. е. фактически то, что она делает, - это комбинация git Fetch и git merge друг за другом. но это может привести к конфликтам, поэтому рекомендуется использовать git Pull с чистым копировать.
мы просто говорим:
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 позволяет применять хронологически более старые коммиты после новых коммитов. Из-за этого акт передачи коммитов между репозиториями разбивается на два этапа:
копировать новые коммиты из удаленного филиала, чтобы скопировать удаленный филиал в локальной РЕПО.
(РЕПО операция РЕПО)
master@remote >> remote/origin/master@local
интеграция новых коммитов в локальную ветку
(внутри-РЕПО операции)
remote/origin/master@local >> master@local
есть два способа сделать шаг 2. Вы можете:
- Fork local branch после последнего общего предка и добавления новых коммитов параллельно коммитам, которые уникальны для локального репозитория, завершается слиянием коммитов, закрывая вилку.
- вставить новые коммиты после последнего общего предка и повторно совершает уникальный для локального репозитория.
на
git
терминология, Шаг 1-этоgit fetch
, Шаг 2git merge
илиgit rebase
git pull
иgit fetch
иgit merge
в чем разница между
git pull
иgit fetch
?чтобы понять это, вам сначала нужно понять, что ваш локальный git поддерживает не только ваш локальный репозиторий, но и локальную копию удаленного репозитория.
git fetch
обновляет локальную копию удаленного репозитория. Например, если ваш удаленный репозиторий является GitHub - вы можете извлечь любые изменения, внесенные в удаленный репозиторий, в свою локальную копию удаленный репозиторий. Это позволит вам выполнять такие операции, как сравнение или слияния.
git pull
с другой стороны будет сбить изменения в удаленном репозитории, где вы держите свой собственный код. Как правило,git pull
будетgit fetch
сначала обновите локальную копию удаленного репозитория, а затем она объединит изменения в вашем собственном репозитории кода и, возможно, в вашей рабочей копии.
Git получает ветку последней версии от удаленного до локального с помощью двух команд:
git fetch: Git собирается получить последнюю версию с удаленного на локальный, но он не сливается автоматически.
git fetch origin master
git log -p master..origin/master
git merge origin/master
приведенные выше команды означают, что загрузите последнюю версию главной ветви из источника из удаленного в главную ветвь источника. А затем сравнивает локальную главную ветвь и исходную главную ветвь. Наконец, слияние.
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 поддерживает копию вашего собственного кода и удаленный репозиторий.
команда
git fetch
делает вашу локальную копию актуальной, получая данные из удаленного репозитория. Причина, по которой нам это нужно, заключается в том, что кто-то другой, возможно, внес некоторые изменения в код, и вы хотите, чтобы держать себя в курсе.команда
git pull
приносит изменения в удаленном репозитории, где вы храните свой собственный код. Обычно,git pull
делает это, делая ' git fetch’ сначала необходимо обновить локальную копию удаленного репозитория, а затем объединить изменения в свой собственный репозиторий кода и, возможно, в рабочую копию.
простое графическое представление для новичков,
здесь
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
это будет перебазировать код в локальный. перед этим убедитесь, что вы находитесь в правильной ветке.