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

9087
голосов

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

задан Pablo 15 нояб. '08 в 12:51
источник

43 ответов

  • 1
  • 2
7633
голосов

В простейших терминах git pull выполняется a git fetch, за которым следует git merge.

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

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

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

Git документация: Git pull

ответ дан Greg Hewgill 15 нояб. '08 в 12:52
источник
1666
голосов
  • Когда вы используете pull, Git пытается автоматически выполнить вашу работу за вас. Это контекстно-зависимая, поэтому Git объединит любые выталкиваемые коммиты в ветку, в которой вы сейчас работаете. pull автоматически объединяет коммиты, не позволяя вам сначала просмотреть их, Если вы не очень хорошо управляете своими веткими, вы можете столкнуться с частыми конфликтами.

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

ответ дан Mouna Cheikhna 18 авг. '11 в 11:53
источник
882
голосов

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

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

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

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

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

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

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

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

ответ дан MikeD 31 марта '13 в 21:43
источник
494
голосов

Вот Оливер Стил: как все это сочетается вместе:

enter image description here

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

ответ дан Contango 09 июня '15 в 16:30
источник
390
голосов

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

git fetch
git diff ...origin
ответ дан mepster 07 мая '10 в 22:23
источник
312
голосов

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

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

когда вы начинаете работать, и делаете это, вы переводите указатель мастера на HEAD + ваши фиксации. Но указатель origin/master все еще указывает на то, что было, когда вы клонировали.

Таким образом, разница будет:

  • Если вы выполните git fetch, он просто извлечет все изменения в удаленном репозитории (GitHub) и переместите начало/мастер-указатель на HEAD. Тем временем ваш мастер локального ветки будет продолжать указывать, где он находится.
  • Если вы выполните git pull, он будет выполнять в основном извлечение (как объяснялось ранее) и объединить любые новые изменения в основную ветку и переместить указатель на HEAD.
ответ дан Gerardo 11 мая '12 в 21:37
источник
146
голосов

Коротко

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 клоном (и 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 здесь. См. Комментарий @Justin Ohms в другом ответе.

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

ответ дан Snowcrash 13 апр. '13 в 20:31
источник
146
голосов

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

введите описание изображения здесь

ответ дан thedarkpassenger 25 янв. '16 в 20:28
источник
136
голосов
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.

Вы бы потянули, если хотите, чтобы истории слились, вы бы получили, если бы вы просто "хотели код", поскольку кто-то из них помещал некоторые статьи здесь.

ответ дан Vinko Vrsalovic 15 нояб. '08 в 12:52
источник
128
голосов

Вы можете извлечь из удаленного репозитория, увидеть различия, а затем вытащить или объединить.

Это пример удаленного репозитория с именем origin и веткой с именем master, отслеживающей удаленную ветвь origin/master:

git checkout master                                                  
git fetch                                        
git diff origin/master
git rebase origin master
ответ дан Antonio Bardazzi 21 марта '11 в 14:07
источник
118
голосов

Короткий и простой ответ заключается в том, что 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) тщательно.

ответ дан jfmercer 15 мая '11 в 23:53
источник
99
голосов

Бонус:

Говоря о вытягивании и извлечении в приведенных выше ответах, я хотел бы поделиться интересным трюком,

git pull --rebase

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

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

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

ответ дан Sazzad Hissain Khan 23 дек. '15 в 18:31
источник
96
голосов

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

                                         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   .
                  .
                  .
FETCH  *------------------>*
Your local cache of the remote is updated with the origin (or multiple
external sources, that is git 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.

Некоторые основные преимущества наличия зеркального отображения пульта:

  • Производительность (прокрутка всех коммитов и сообщений, не пытаясь сжать ее через сеть)
  • Обратная связь о состоянии вашего локального репо (например, я использую Atlassian SourceTree, который даст мне лампочку, указывающую, буду ли я идти вперед или назад по сравнению с источником. обновить с помощью GIT FETCH).
ответ дан Justus Romijn 20 февр. '14 в 0:18
источник
92
голосов

enter image description here

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

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

ответ дан th3sly 06 февр. '15 в 14:48
источник
82
голосов

Я тоже боролся с этим. На самом деле я попал сюда с поиском 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+               -
---------------------     -----------------------     -----------------------

Это помогло мне понять, почему выборка очень важна.

ответ дан pn1 dude 17 июля '12 в 19:43
источник
65
голосов

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

git pull == git fetch + git merge

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

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

ответ дан Selvamani 21 февр. '13 в 16:25
источник
64
голосов

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

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

ответ дан Michael Durrant 19 сент. '13 в 23:01
источник
62
голосов

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

ответ дан ntanase 27 нояб. '12 в 0:58
источник
54
голосов

Git Fetch

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

Git Слияние

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

Git Pull

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

ответ дан Pinkesh Sharma 14 июля '16 в 0:23
источник
42
голосов

Разница между GIT Fetch и GIT Pull может быть объяснена следующим сценарием: (Помня, что картинки говорят громче, чем слова!, я представил изобразительное представление)

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

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

введите описание изображения здесь

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

введите описание изображения здесь

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

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

введите описание изображения здесь

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

введите описание изображения здесь

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

введите описание изображения здесь

ответ дан Aman Tiwari 07 февр. '17 в 17:15
источник
41
голос

Единственное различие между git pull и git fetch заключается в следующем:

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

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

то есть. git pull = git fetch + git merge...

ответ дан Rohitashv Singhal 04 июня '13 в 17:08
источник
35
голосов

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

  • Копирование новых коммитов из удаленной ветки для копирования этой удаленной ветки внутри локального репо.

    (операция репо для операции репо) master@remote >> remote/origin/master@local

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

    (операция внутри-репо) remote/origin/master@local >> master@local

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

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

В терминологии git шаг 1 равен git fetch, шаг 2 равен git merge или git rebase

git pull составляет git fetch и git merge

ответ дан Pawel Furmaniak 28 нояб. '13 в 20:03
источник
32
голосов

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

git fetch

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

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

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

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

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

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


git pull

Он применит изменения от удаленного к текущему ветки в локальном...

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

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

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

Значения по умолчанию для и считываются с "remote" и "merge" для текущей ветки, как установлено git -branch -track.


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

git pull и  git fetch

ответ дан Alireza 21 июня '17 в 12:48
источник
28
голосов

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

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

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

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

ответ дан Donal 19 мая '15 в 14:57
источник
27
голосов

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 может быть более безопасным, поскольку перед слиянием мы можем видеть изменения и решать, сходиться ли.

ответ дан Marcus Thornton 12 авг. '14 в 7:00
источник
26
голосов

git pull == (git fetch + git merge)

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

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

ответ дан Iggy 20 сент. '13 в 1:41
источник
23
голосов

Попытка быть понятной и простой.

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

ответ дан montells 29 июля '15 в 21:38
источник
23
голосов

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

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

Команда git pull приносит изменения в удаленном репозитории, где вы храните свой собственный код. Обычно git pull делает это, делая сначала

ответ дан Pokemon 13 сент. '15 в 21:48
источник
21
голос

Из Pro Git & sect; 2.5 Git Основы - Работа с пультами: выборка и извлечение из ваших пульта дистанционного управления:

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

Если у вас есть ветвь, настроенная для отслеживания удаленной ветки, вы можете использовать git pull для автоматического извлечения, а затем слияния удаленного войдите в свою текущую ветку. Это может быть проще или более удобный рабочий процесс для вас; и по умолчанию команда git cloneавтоматически настраивает локальную ведущую ветвь для отслеживания удаленного master на сервере, с которого вы клонировали (при условии, что мастер-ветвь). Выполнение git pull обычно выбирает данные из сервер, с которого вы первоначально клонировали, и автоматически пытается слить его в код, который вы сейчас работаете.

ответ дан Zhenxiao Hao 28 июля '14 в 11:28
источник
20
голосов
git pull = git fetch + git merge 
ответ дан Saqib R. 12 июля '15 в 6:54
источник
  • 1
  • 2

Другие вопросы по меткам