git-pull example vs - Qual é a diferença entre 'git pull' e 'git fetch'?





15 Answers

  • Quando você usa pull , o Git tenta fazer seu trabalho automaticamente por você. É sensível ao contexto , então o Git irá mesclar quaisquer commits puxados na ramificação em que você está trabalhando atualmente. pull automaticamente mescla os commits sem permitir que você os revise primeiro . Se você não gerencia suas filiais de perto, você pode entrar em conflitos freqüentes.

  • Quando você fetch , o Git reúne qualquer confirmação da ramificação de destino que não existe em sua ramificação atual e a armazena em seu repositório local . No entanto, ele não os mescla com sua ramificação atual . Isto é particularmente útil se você precisa manter seu repositório atualizado, mas está trabalhando em algo que pode quebrar se você atualizar seus arquivos. Para integrar os commits em seu branch master, você usa merge .

branch origin master

Moderador Nota: Como essa pergunta já teve sessenta e sete respostas postadas (algumas delas excluídas), considere se você está ou não contribuindo com algo novo antes de postar outra.

Quais são as diferenças entre git pull e git fetch ?







Custou-me um pouco entender qual era a diferença, mas esta é uma explicação simples. master em seu localhost é um ramo.

Quando você clona um repositório, você obtém todo o repositório no host local. Isso significa que, nesse momento, você tem um ponteiro de origem / mestre para HEAD e o mestre apontando para o mesmo HEAD .

quando você começar a trabalhar e fizer com que você avance o ponteiro mestre para HEAD + seus commits. Mas o ponteiro de origem / mestre ainda está apontando para o que era quando você clonou.

Então a diferença será:

  • Se você fizer uma git fetch ele irá apenas buscar todas as mudanças no repositório remoto ( GitHub ) e mover o ponteiro de origem / mestre para HEAD . Enquanto isso, seu mestre de filial local continuará apontando para onde está.
  • Se você fizer um git pull , ele basicamente buscará (como explicado anteriormente) e mesclará quaisquer novas mudanças em sua ramificação master e moverá o ponteiro para HEAD .



Brevemente

git fetch é semelhante ao pull mas não se mescla. isto é, ele busca atualizações remotas ( refs e objects ), mas seu local permanece o mesmo (ou seja, origin/master é atualizado, mas o master permanece o mesmo).

git pull puxa para baixo de um controle remoto e instantaneamente se funde.

Mais

git clone clona um repo.

git rebase salva o material de sua ramificação atual que não está no branch upstream para uma área temporária. Sua filial agora é a mesma de antes de você iniciar suas alterações. Então, git pull -rebase irá puxar as mudanças remotas, rebobinar sua filial local, repetir suas mudanças sobre a parte superior de sua ramificação atual, uma por uma, até que você esteja atualizado.

Além disso, git branch -a mostrará exatamente o que está acontecendo com todas as suas filiais - local e remota.

Esta postagem do blog foi útil:

A diferença entre git pull, git fetch e git clone (e git rebase) - Mike Pearce

e abrange git pull , git fetch , git clone e git rebase .

====

ATUALIZAR

Eu pensei em atualizar isso para mostrar como você realmente usa isso na prática.

  1. Atualize seu repo local do controle remoto (mas não mescle):

    git fetch

  2. Depois de baixar as atualizações, vamos ver as diferenças:

    git diff mestre origem / mestre

  3. Se você está feliz com essas atualizações, então mesclar:

    git pull

Notas:

No passo 2: Para mais informações sobre diffs entre locais e remotos, veja: comparar ramificações git locais com ramificações remotas?

No passo 3: É provavelmente mais preciso (por exemplo, em um repo de mudança rápida) para fazer uma git rebase origin aqui. Veja o comentário de @Justin Ohms em outra resposta.

Veja também: longair.net/blog/2009/04/16/git-fetch-and-merge




Você pode buscar em um repositório remoto, ver as diferenças e, em seguida, puxar ou mesclar.

Este é um exemplo para um repositório remoto chamado origin e uma ramificação chamada master rastreamento da origin/master filial remota:

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



Esta representação gráfica interativa é muito útil para entender o git: http://ndpsoftware.com/git-cheatsheet.html

git fetch apenas "baixa" as mudanças do remoto para o seu repositório local. git pull download das alterações e as mescla em sua ramificação atual. "Em seu modo padrão, o git pull é uma forma abreviada de git fetch seguida por git merge FETCH_HEAD ."




OK , aqui estão algumas informações sobre git pull e git fetch , para que você possa entender as diferenças reais ... em poucas palavras simples, o fetch obtém os dados mais recentes, mas não o código muda e não vai mexer no seu código de ramificação local atual , mas puxar obter as alterações de código e mesclar o seu ramo local, continue a ler para obter mais detalhes sobre cada um:

git fetch

Ele irá baixar todos os refs e objetos e quaisquer novas ramificações para o seu Repositório local ...

Buscar ramificações e / ou tags (coletivamente, "refs") de um ou mais repositórios, junto com os objetos necessários para completar seus históricos. As ramificações de rastreamento remoto são atualizadas (veja a descrição abaixo para saber como controlar esse comportamento).

Por padrão, qualquer tag que aponta para os históricos que estão sendo buscados também é buscada; O efeito é buscar tags que apontam para as ramificações nas quais você está interessado. Esse comportamento padrão pode ser alterado usando as opções --tags ou --no-tags ou configurando remote..tagOpt. Ao usar um refspec que busca tags explicitamente, você também pode buscar tags que não apontem para as ramificações de seu interesse.

git fetch pode buscar a partir de um único repositório nomeado ou URL, ou de vários repositórios de uma vez, se for dado e houver um controle remoto. entrada no arquivo de configuração. (Veja git-config 1 ).

Quando nenhum controle remoto é especificado, por padrão, o remoto de origem será usado, a menos que haja uma ramificação upstream configurada para a ramificação atual.

Os nomes das referências que são buscadas, juntamente com os nomes de objetos para os quais apontam, são gravados em .git / FETCH_HEAD. Esta informação pode ser usada por scripts ou outros comandos git, como git-pull.

git pull

Ele aplicará as alterações do remoto ao ramo atual no local ...

Incorpora as alterações de um repositório remoto no ramo atual. Em seu modo padrão, o git pull é uma forma abreviada de buscar o git seguido por git merge FETCH_HEAD.

Mais precisamente, git pull executa git fetch com os parâmetros fornecidos e chama git merge para mesclar os cabeçalhos recuperados na ramificação atual. Com o --rebase, ele executa o git rebase em vez do git merge.

deve ser o nome de um repositório remoto conforme transmitido para git-fetch 1 . pode nomear uma referência remota arbitrária (por exemplo, o nome de uma tag) ou até mesmo uma coleção de refs com ramificações de rastreamento remoto correspondentes (por exemplo, refs / heads / : refs / remotes / origin / ), mas geralmente é o nome de uma ramificação no repositório remoto.

Valores padrão para e são lidos a partir da configuração "remote" e "merge" para a ramificação atual, conforme definido por git-branch --track.

Eu também crio o visual abaixo para mostrar como git fetch e git pull trabalham juntos ...

1




Eu lutei com isso também. Na verdade eu cheguei aqui com uma pesquisa no google exatamente da mesma pergunta. Lendo todas estas respostas, finalmente, pintei uma imagem na minha cabeça e decidi tentar fazer isso para baixo, olhando para o estado dos dois repositórios e um sandbox e ações realizadas ao longo do tempo, enquanto assistia a versão deles. Então aqui está o que eu criei. Por favor, corrija-me se eu errei em qualquer lugar.

Os três repos com uma busca:

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

Os três repos com um puxão

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

Isso me ajudou a entender por que uma busca é muito importante.




Nós simplesmente dizemos:

git pull == git fetch + git merge

Se você executar git pull, não precisará mesclar os dados ao local. Se você executar git fetch, isso significa que você deve executar git mergepara obter o código mais recente para sua máquina local. Caso contrário, o código da máquina local não seria alterado sem mesclar.

Então, no Git Gui, quando você busca, você precisa mesclar os dados. A busca em si não fará o código mudar no seu local. Você pode verificar isso quando você atualizar o código, buscando uma vez buscar e ver; o código não vai mudar. Então você mescla ... Você verá o código alterado.




git fetchirá recuperar os ramos remotos para que você possa git diffou git mergeeles com o ramo atual. git pullirá executar buscar no brach remoto rastreado pelo ramo atual e depois mesclar o resultado. Você pode usar git fetchpara ver se há alguma atualização na ramificação remota sem precisar mesclá-las com sua ramificação local.




A única diferença entre git pulle git fetché isso:

git pull puxa de um ramo remoto e mescla-lo.

git fetch só busca do ramo remoto, mas não se fundem

ou seja, git pull = git buscar + git merge ...




Qual é a diferença entre git pulle git fetch?

Para entender isso, primeiro você precisa entender que o seu git local mantém não apenas seu repositório local, mas também mantém uma cópia local do repositório remoto.

git fetchtraz sua cópia local do repositório remoto até à data. Por exemplo, se o seu repositório remoto for o GitHub - você pode querer buscar quaisquer alterações feitas no repositório remoto para sua cópia local do repositório remoto. Isso permitirá que você realize operações como comparar ou mesclar.

git pullpor outro lado, derrubará as alterações no repositório remoto para onde você mantém seu próprio código. Normalmente, git pullfará o git fetchprimeiro para atualizar a cópia local do repositório remoto e, em seguida, mesclará as alterações em seu próprio repositório de código e possivelmente em sua cópia de trabalho.




git pull == (git fetch + git merge)

git fetch não muda para ramificações locais.

Se você já tem um repositório local com um controle remoto configurado para o projeto desejado, você pode pegar todas as ramificações e tags do remoto existente usando git fetch. ... O Fetch não faz alterações nas ramificações locais, portanto, você precisará mesclar uma ramificação remota com uma ramificação local emparelhada para incorporar as novas alterações de busca. do github




Na verdade, o Git mantém uma cópia do seu próprio código e do repositório remoto.

O comando git fetchatualiza sua cópia local obtendo dados do repositório remoto. A razão pela qual precisamos disso é porque alguém pode ter feito algumas alterações no código e você quer se manter atualizado.

O comando git pulltraz as mudanças no repositório remoto para onde você guarda seu próprio código. Normalmente, git pullisso é feito primeiro fazendo uma "busca do git" para atualizar a cópia local do repositório remoto e, em seguida, mesclar as alterações em seu próprio repositório de código e possivelmente em sua cópia de trabalho.




Uma representação gráfica simples para iniciantes,

Aqui,

git pull  

irá buscar código do repositório e rebase com o seu local ... no git pull existe a possibilidade de novos commits serem criados.

mas em ,

git fetch

irá buscar o código do repositório e precisamos rebase-lo manualmente usando git rebase

Por exemplo: eu vou buscar do mestre do servidor e rebase-lo no meu mestre local.

1) git pull (rebase será feito automaticamente):

git pull origin master

aqui a origem é o seu repo master remoto é o seu ramo

2) git fetch (precisa se rebase manualmente):

git fetch origin master

ele irá buscar as mudanças do servidor de origem. e estará em seu local até que você o rebase sozinho. Precisamos corrigir os conflitos manualmente, verificando códigos.

git rebase origin/master

isso irá rebase o código para local. antes disso, garanta que você está no ramo certo.






Related