web-dev-qa-db-pt.com

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

Moderador Nota: Dado que esta questão já teve sessenta e sete respostas postadas nela (algumas delas deletadas), considere se você estácontribuindo com alguma coisa novaantes postando outro.

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

10728
pupeno

Nos termos mais simples, git pull faz um git fetch seguido por um git merge.

Você pode fazer um git fetch a qualquer momento para atualizar suas ramificações de controle remoto em refs/remotes/<remote>/.

Essa operação nunca altera nenhuma das suas ramificações locais em refs/heads, e é seguro fazê-lo sem alterar sua cópia de trabalho. Eu já ouvi falar de pessoas executando git fetch periodicamente em um cron job em segundo plano (embora eu não recomendaria fazer isso).

Um git pull é o que você faria para atualizar uma filial local com sua versão remota, além de atualizar suas outras ramificações de rastreamento remoto.

Documentação do Git: git pull

8962
Greg Hewgill
  • Quando você usa pull, o Git tenta fazer automaticamente o seu trabalho para você. É sensível ao contexto , então o Git irá mesclar quaisquer commits puxados na ramificação em que você está trabalhando atualmente. pull mescla automaticamente os commits sem permitir que você os revise primeiro . Se você não gerencia seus departamentos de perto, pode ter conflitos frequentes.

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

1969
Mouna Cheikhna

É importante contrastar a filosofia de design do git com a filosofia de uma ferramenta de controle de fonte mais tradicional como o SVN.

O Subversion foi projetado e construído com um modelo cliente/servidor. Existe um único repositório que é o servidor, e vários clientes podem buscar o código do servidor, trabalhar nele e depois enviá-lo de volta ao servidor. A suposição é que o cliente sempre pode entrar em contato com o servidor quando ele precisar executar uma operação.

O Git foi projetado para suportar um modelo mais distribuído sem necessidade de um repositório central (embora você possa certamente usar um, se quiser). O git também foi projetado para que o cliente e o "servidor" não precisem estar on-line ao mesmo tempo. O Git foi projetado para que as pessoas em um link não confiável pudessem trocar códigos via e-mail, mesmo. É possível trabalhar completamente desconectado e gravar um CD para trocar código via git.

Para suportar esse modelo, o git mantém um repositório local com seu código e também um repositório local adicional que espelha o estado do repositório remoto. Mantendo uma cópia do repositório remoto localmente, o git pode descobrir as mudanças necessárias mesmo quando o repositório remoto não está acessível. Mais tarde, quando você precisar enviar as alterações para outra pessoa, o git poderá transferi-las como um conjunto de alterações de um ponto no tempo conhecido pelo repositório remoto.

  • git fetch é o comando que diz "atualize minha cópia local do repositório remoto". 

  • git pull diz "traga as mudanças no repositório remoto para onde eu mantenho meu próprio código."

Normalmente git pull faz isto fazendo um git fetch para trazer a cópia local do repositório remoto até a data, e então mesclando as mudanças em seu próprio repositório de código e possivelmente em sua cópia de trabalho.

O take away é ter em mente que muitas vezes há pelo menos três cópias de um projeto em sua estação de trabalho. Uma cópia é seu próprio repositório com seu próprio histórico de confirmação. A segunda cópia é a sua cópia de trabalho, onde você está editando e construindo. A terceira cópia é sua cópia "em cache" local de um repositório remoto.

1104
MikeD

Aqui está a imagem de Oliver Steele de como tudo isso se encaixa :

enter image description here

Se houver interesse suficiente, suponho que eu possa atualizar a imagem para adicionar git clone e git merge... 

744
Contango

Um caso de uso de git fetch é que o seguinte informará quaisquer alterações na ramificação remota desde o último pull ... para que você possa verificar antes de fazer uma pull real, o que pode alterar os arquivos na ramificação atual e na cópia de trabalho.

git fetch
git diff ...Origin
446
mepster

Custou-me um pouco entender qual era a diferença, mas esta é uma explicação simples. master no 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 um 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 um git fetch, ele irá apenas buscar todas as mudanças no repositório remoto ( GitHub ) e mover o ponteiro Origin/master 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.
351
Gerardo

Às vezes, uma representação visual ajuda.

enter image description here

195
thedarkpassenger

Brevemente

git fetch é semelhante a pull, mas não é mesclado. Ou seja, ele busca atualizações remotas (refs e objects), mas seu local permanece o mesmo (ou seja, Origin/master é atualizado, mas master permanece o mesmo).

git pull desce 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á na ramificação de envio para uma área temporária. Sua filial agora é a mesma de antes de você iniciar suas alterações. Então, git pull -rebase irá baixar as alterações remotas, rebobinar sua filial local, repetir suas alterações na 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 master Origin/master 
    
  3. Se você estiver satisfeito com essas atualizações, mescle:

    git pull
    

Notas:

No passo 2: Para mais informações sobre diffs entre locais e remotos, veja: Como comparar um branch git local com seu branch remoto?

Na etapa 3: é provavelmente mais preciso (por exemplo, em um repo de alteração rápida) para fazer um git rebase Origin aqui. Veja comentário de @Justin Ohms em outra resposta.

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

189
Snowcrash
 git-pull - Busca e fusão com outro repositório ou filial local 
 SINOPSE 
 
 git pull… 
 DESCRIÇÃO 
 
 Executa git-fetch com os parâmetros fornecidos e chama git-merge para mesclar a (s) 
 Cabeça (s) recuperada (s) na ramificação atual. Com --rebase, chama git-rebase 
 Ao invés de git-merge. 
 
 Note que você pode usar. (diretório atual) como o <repositório> para puxar 
 do repositório local - isso é útil ao mesclar ramificações locais 
 na ramificação atual. 
 
 que as opções significadas para git-pull em si e git-merge 
 devem ser dadas antes das opções significadas para git-fetch. 

Você puxaria se quisesse que as histórias fossem mescladas, você buscaria se você apenas "quisesse o codez", já que algumas pessoas estavam etiquetando alguns artigos por aqui.

164
Vinko Vrsalovic

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 um ramo chamado master rastreando o ramo remoto Origin/master:

git checkout master                                                  
git fetch                                        
git diff Origin/master
git rebase Origin master
151
Antonio Bardazzi

A resposta curta e fácil é que git pull é simplesmente git fetch seguido de git merge.

É muito importante notar que git pull irá automaticamente se você quiser ou não. Isso poderia, obviamente, resultar em conflitos de mesclagem. Digamos que seu controle remoto seja Origin e sua ramificação seja master. Se você git diff Origin/master antes de puxar, você deve ter alguma idéia dos potenciais conflitos de mesclagem e pode preparar sua filial local de acordo. 

Além de puxar e empurrar, alguns fluxos de trabalho envolvem git rebase, como este, que eu parafraseio do artigo vinculado:

git pull Origin master
git checkout foo-branch
git rebase master
git Push Origin foo-branch

Se você se encontrar em tal situação, você pode ser tentado a git pull --rebase. A menos que você realmente saiba o que está fazendo, eu aconselharia contra isso. Este aviso é da página man para git-pull, versão 2.3.5:

Este é um modo de operação potencialmente perigoso. Ele reescreve a história , que não é um bom presságio quando você já publicou essa história . Não use esta opção a menos que você tenha lido o git-rebase (1) Cuidadosamente.

145
jfmercer

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, fetch obtém os dados mais recentes, mas não o código muda e não vai para mexer com o seu código de ramificação local atual, mas pull 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 fará o download de todos os refs e objects e de quaisquer novas ramificações para o seu Repositório local ...

Buscar ramificações e/ou tags (coletivamente, "refs") de um ou mais Outros repositórios, junto com os objetos necessários para completar suas histórias . 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 aponte para os históricos que estão sendo buscados é Também buscada; o efeito é buscar tags que apontam para ramificações que 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 é dado e há um controle remoto . entrada no arquivo de configuração. (Veja git-config 1 ).

Quando nenhum controle remoto é especificado, por padrão, o controle remoto Origin 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 dos 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 de remote ao current branch no local ...

Incorpora as mudanças de um repositório remoto na ramificação atual. Em seu modo padrão, git pull é um atalho para a busca do 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 git rebase em vez de git merge.

deve ser o nome de um repositório remoto como passado para git-fetch 1 . pode nomear um ref remoto arbitrário (por exemplo, o nome de um tag) ou até mesmo uma coleção de refs com ramificações de rastreamento remoto correspondentes (por exemplo, refs/heads/: refs/remotos/Origem/), 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" da 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 ...

git pull and git fetch

126
Alireza

enter image description here

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

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

121
th3sly

Bônus:

Ao falar de pull & fetch nas respostas acima, eu gostaria de compartilhar um truque interessante,

git pull --rebase

Este comando acima é o comando mais útil na minha vida que salvou muito tempo.

Antes de enviar seus novos commits para o servidor, experimente este comando e ele sincronizará automaticamente as mudanças mais recentes do servidor (com uma busca + mesclagem) e colocará seu commit no topo no log git. Não precisa se preocupar com pull/merge manual.

Encontre detalhes em: http://gitolite.com/git-pull--rebase

119
Sazzad Hissain Khan

Eu gosto de ter alguma representação visual da situação para entender essas coisas. Talvez outros desenvolvedores também gostariam de ver, então aqui está minha adição. Eu não estou totalmente certo de que tudo está correto, então, por favor, comente se você encontrar algum erro.

                                         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.

Algumas vantagens importantes para ter um espelho buscado do controle remoto são:

  • Performance (percorra todos os commits e mensagens sem tentar espremer através da rede)
  • Feedback sobre o estado do seu repositório local (por exemplo, eu uso o SourceTree da Atlassian, que me dará uma lâmpada indicando se eu estou comprometido com antecedência ou atrasado em relação à Origem. Essas informações podem ser atualizadas com um GET FETCH ).
109
Justus Romijn

Eu também lutei com isso. 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 eu decidi tentar baixar isso olhando para o estado dos 2 repositórios e 1 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.

99
pn1 dude

A diferença entre GIT Fetch e GIT Pull pode ser explicada com o seguinte cenário: (Tendo em mente que as imagens falam mais que palavras!), Eu forneci representação pictórica)

Vamos dar um exemplo de que você está trabalhando em um projeto com os membros de sua equipe. Então, o seu será uma ramificação principal do projeto e todos os contribuidores devem bifurcá-lo em seu próprio repositório local e, em seguida, trabalhar nessa ramificação local para modificar/adicionar módulos e, em seguida, retroceder para a ramificação principal.

Então, Initial State dos dois ramos quando você bifurcou o projeto principal em seu repositório local será como este- (A, B e C são módulos já completados do projeto)

enter image description here

Agora, você começou a trabalhar no novo módulo (suponha que D) e quando você completou o módulo D que você quer enviar para o branch principal, mas enquanto isso o que acontece é que um de seus colegas desenvolveu o novo módulo E, F e modificado C.
Agora, o que aconteceu é que o seu repositório local está atrasado em relação ao progresso original do projeto e, portanto, empurrar suas alterações para a ramificação principal pode causar conflito e pode causar mau funcionamento do Módulo D.

enter image description here

Para evitar tais problemas e para trabalhar em paralelo com o progresso original do projeto são duas maneiras:

1. Git Fetch- Isto irá fazer o Download de todas as mudanças que foram feitas no projeto Origin/main branch que não estão presentes na sua filial local. E esperará pelo comando Git Merge para aplicar as mudanças que foram buscadas em seu Repositório ou ramificação.

enter image description here

Portanto, agora você pode monitorar cuidadosamente os arquivos antes de mesclá-los ao seu repositório. E você também pode modificar D, se necessário, por causa do Modified C.

enter image description here

2. Git Pull- Isto irá atualizar seu branch local com o Origin/branch principal, isto é, na verdade o que ele faz é uma combinação de Git Fetch e Git se fundem um após outro. Mas isso pode causar Conflitos para ocorrer, por isso é recomendado usar o Git Pull com uma cópia limpa.

enter image description here

89
Aman Tiwari

Nós simplesmente dizemos:

git pull == git fetch + git merge

Se você executar git pull, não será necessário mesclar os dados ao local. Se você executar git fetch, isso significa que você deve executar git merge para obter o código mais recente em 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. Buscar-se 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.

82
Selvamani

git fetch retira o código do servidor remoto para suas ramificações de rastreamento em seu repositório local. Se o seu controle remoto for denominado Origin (o padrão), então essas ramificações estarão dentro de Origin/, por exemplo Origin/master, Origin/mybranch-123, etc. Estas não são suas ramificações atuais, elas são cópias local dessas ramificações do servidor.

git pull faz um git fetch mas depois also mescla o código do branch de rastreamento em sua versão local atual daquele branch. Se você ainda não está preparado para essas mudanças, apenas git fetch primeiro.

80
Michael Durrant

git fetch irá recuperar as ramificações remotas para que você possa git diff ou git merge-las com a ramificação atual. git pull executará a busca no brach remoto rastreado pelo ramo atual e depois mesclará o resultado. Você pode usar git fetch para ver se há alguma atualização na ramificação remota sem precisar mesclá-las com sua ramificação local.

75
ntanase

Git Fetch

Você faz o download de alterações para sua ramificação local do Origin por meio de busca. O Fetch solicita o repo remoto para todos os commits que outros fizeram, mas você não tem em seu repositório local. Busque os downloads dessas confirmações e adicione-os ao repositório local.

Git Merge

Você pode aplicar as alterações baixadas por meio da busca usando o comando merge. A mesclagem levará os commits recuperados da busca e tentará adicioná-los à sua ramificação local. A mesclagem manterá o histórico de commits de suas alterações locais, de modo que quando você compartilhar sua branch com Push, o Git saberá como os outros podem mesclar suas alterações.

Git Pull

Buscar e mesclar executar juntos com freqüência suficiente para que um comando que combina os dois, puxar, foi criado. Pull faz uma busca e, em seguida, uma mesclagem para adicionar os commits baixados em sua filial local.

71
Pinkesh Sharma

A única diferença entre git pull e git fetch é que:

git pull recebe de uma ramificação remota e a mescla.

git fetch só busca da ramificação remota, mas não se mescla

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

50
Rohitashv Singhal

O Git permite que commits cronologicamente mais antigos sejam aplicados após commits mais recentes. Por causa disso, o ato de transferir confirmações entre repositórios é dividido em duas etapas:

  1. Copiando novos commits da ramificação remota para a cópia desta ramificação remota dentro do repositório local. 

    (repo a operação de recompra) [email protected] >> remote/Origin/[email protected]

  2. Integração de novos commits à filial local

    (operação dentro do repositório) remote/Origin/[email protected] >> [email protected]

Existem duas maneiras de fazer o passo 2. Você pode:

  1. Ramifique a ramificação local após o último ancestral comum e inclua novas confirmações paralelas às confirmações que são exclusivas do repositório local, finalizadas pela consolidação de consolidação, fechando a bifurcação. 
  2. Inserir novos commits após o último ancestral comum e reaplicar commits exclusivos para o repositório local.

Na terminologia git, o passo 1 é git fetch, o passo 2 é git merge ou git rebase

git pull é git fetch e git merge

44
Pawel Furmaniak

Qual é a diferença entre git pull e 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 fetch traz sua cópia local do repositório remoto atualizada. Por exemplo, se o seu repositório remoto é 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 pull por outro lado, derrubará as mudanças no repositório remoto para onde você guarda seu próprio código. Normalmente, git pull fará um git fetch primeiro 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. 

36
Donal

O Git obtém a ramificação da última versão do remoto para o local usando dois comandos: 

  1. git fetch: Git vai pegar a versão mais recente do remoto para o local, mas ela não é automaticamente mesclada. git fetch Origin mastergit log -p master..Origin/mastergit merge Origin/master

     Os comandos acima significam que o download da versão mais recente do ramo principal de Origem do remoto para o ramo mestre de Origem. Em seguida, compara o ramo mestre local e o ramo mestre de origem. Finalmente, mesclar. 

  2. git pull: O Git obterá a versão mais recente do controle remoto e entrará no local.

    git pull Origin master

     O comando acima é o equivalente a git fetch e git merge. Na prática, git fetch talvez seja mais seguro porque, antes da mesclagem, podemos ver as alterações e decidir se devemos mesclar.

35
Marcus Thornton

git pull == (git fetch + git merge) 

git fetch não muda para branches 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 pareada para incorporar as novas alterações de busca. do github

33
Iggy

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

O comando git fetch atualiza 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 pull traz as mudanças no repositório remoto para onde você guarda seu próprio código. Normalmente, git pull faz isso fazendo uma "git fetch" primeiro para atualizar a cópia local do repositório remoto e, em seguida, mescla as alterações em seu próprio repositório de código e possivelmente em sua cópia de trabalho.

32
Pokemon

Tentando ser claro e simples.

O comando git pull é na verdade uma shortcut para git fetch seguido pela git merge ou a git rebase comando dependendo da sua configuração. Você pode configurar seu repositório Git para que git pull seja uma busca seguida por um rebase.

31
montells

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

enter image description here

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 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 Origin é o seu repositório remoto master é o seu ramo

2) git fetch (precisa se rebase manualmente):

git fetch Origin master

ele buscará as mudanças do servidor da 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.

30
Mohideen ibn Mohammed
git pull = git fetch + git merge 
29
Saqib R.

De Pro Git § 2.5 Fundamentos do Git - Trabalhando com Remotos: Buscando e Puxando de seus Remotos :

É importante observar que o comando fetch puxa os dados para o seu repositório local. Ele não faz Automaticamente mesclá-los com qualquer um dos seus trabalhos nem modifica o que você está Atualmente trabalhando. Você tem que mesclar manualmente em seu trabalho Quando estiver pronto.

Se você tiver uma ramificação configurada para rastrear uma ramificação remota, poderá usar o comando git pull para buscar e mesclar automaticamente uma ramificação remota Na ramificação atual. Este pode ser um fluxo de trabalho mais fácil ou mais Confortável para você; e por padrão, o comando git clone configura automaticamente sua ramificação mestre local para rastrear a ramificação principal remota no servidor do qual você clonou (supondo que o controle remoto tenha um ramo mestre ) . A execução de git pull geralmente busca dados do servidor Do qual você originalmente clonou e tenta mesclar automaticamente No código em que você está trabalhando atualmente.

28
Zhenxiao Hao

git pull 

Ele executa duas funções usando um único comando.

Ele busca todas as alterações feitas na ramificação remota e, em seguida, mescla essas alterações na ramificação local. Você também pode modificar o comportamento de puxar passando --rebase. A diferença entre mesclar e rebase pode ser lida aqui

git fetch

Git fetch faz apenas metade do trabalho de git pull. Ele apenas traz as mudanças remotas para o repositório local, mas não as aplica em suas ramificações. É necessário aplicar explicitamente essas alterações. Isso pode ser feito da seguinte forma:

git fetch
git rebase Origin/master
22
Animesh Sharma

É preciso ter em mente a natureza do git. Você tem remotas e suas filiais locais (não necessariamente as mesmas). Em comparação com outros sistemas de controle de origem, isso pode ser um pouco desconcertante. 

Normalmente, quando você faz o checkout de um controle remoto, é criada uma cópia local que rastreia o controle remoto. 

o git fetch irá trabalhar com o ramo remoto e atualizar suas informações. 

Na verdade, é o caso se outros SWEs estão trabalhando um mesmo ramo, e raramente o caso em um pequeno dev - uma filial - um cenário de projeto.

Seu trabalho no ramo local ainda está intacto. A fim de trazer as mudanças para o seu ramo local você tem que mesclar/rebase as mudanças do ramo remoto.

git pull faz exatamente essas duas etapas (por exemplo, --rebase para rebase em vez de mesclar)

Se o seu histórico local e o histórico remoto tiverem conflitos, você será forçado a fazer a mesclagem durante um git Push para publicar suas alterações.

Assim, realmente depende da natureza do seu ambiente de trabalho e da experiência do que usar.

22
g24l

De git cheat sheet

git fetch <remote> // Download all changes from <remote>, but don't integrate into HEAD
git pull <remote> <branch> // Download changes and directly merge/integrate into HEAD
20
Nan Xiao

Pelo que entendi, 

Git pull - Puxa para baixo a partir de um controle remoto especificado (especificado pelo usuário) e irá imediatamente mesclá-lo em um branch no qual estamos atualmente. É basicamente uma mistura de comandos Fetch and Merge.

Git Fetch - É o mesmo que Pull, mas não fará nenhuma fusão. Portanto, você pode monitorar cuidadosamente os arquivos antes de mesclá-los. 

Este url deve ser de ajuda para melhor entendimento: A diferença entre git pull, git fetch e git clone (e git rebase).

17
Pragyaditya Das

Em suma e simples termos:

git fetch: Veja se há coisas novas.

git pull: Pegue as coisas novas e coloque-as em cima das suas coisas. 

8
miva2

Acredito que a maioria das respostas respondeu bem à diferença. Gostaria de enfatizar quando usar o que em vez disso.

Enter image description here

A busca pode ser útil quando você precisa obter a atualização de outros desenvolvedores, mas deseja continuar seu trabalho sem problemas. As pessoas que frequentemente querem ficar offline e trabalham usam fetch para obter a atualização mais recente até que ele/ela esteja on-line. Mais tarde, quando ele/ela estiver confortável com suas alterações, mescla as do ramo em seu espaço de trabalho.

Considerando que as pessoas que estão trabalhando on-line e estão muito seguras de suas alterações e desejam obter o código mais recente e merge imediatamente usam pull. Eu raramente uso fetch porque para verificar as atualizações mais recentes eu verifico através do site do GitHub e sempre trabalho offline. Como mencionei, você pode usar o cenário acima.

5
ishandutta2007

Git Fetch

Ajuda você a conhecer as últimas atualizações de um git repository. Digamos que você trabalhe em uma equipe usando GitFlow, onde a equipe está trabalhando em várias branches (recursos). Com git fetch --allcommand você pode conhecer todas as novas branches dentro de repository.

Principalmente git fetch é usado com git reset. Por exemplo, você deseja reverter todas as alterações locais para o estado atual do repositório.

git fetch --all // get known about latest updates
git reset --hard Origin/[branch] // revert to current branch state

Git pull

Este comando atualiza sua branch com o estado atual repositorybranch. Vamos continuar com GitFlow. O recurso múltiplo branches era merged para develop e quando você deseja desenvolver novos recursos para o projeto, você deve ir para o desenvolvimento branch e fazer um git pull para obter o estado atual de developbranch

Documentação para o GitFlow https://Gist.github.com/peterdeweese/4251497

3
Andrei Todorut

Git fetch sincroniza o catálogo do repositório remoto com o seu local. Ele não irá mesclar as alterações de arquivo/código do remoto para o seu ramo local.

O Git Pull faz o download das alterações relacionadas à sua ramificação local atual e, em seguida, as mescla.

1
Arnel Lenteria

Deste incrível tutorial Attlassian

O comando git fetch faz o download de confirmações, arquivos e referências de um repositório remoto para o repositório local. 

Buscar é o que você faz quando quer ver o que todo mundo else está trabalhando. É semelhante ao svn update, pois permite que você veja como o histórico central progrediu, mas isso não força você a mesclar as alterações em seu repositório. Git isolates buscou conteúdo como a partir do conteúdo local existente, tem absolutamente nenhum efeito no seu trabalho de desenvolvimento local. O conteúdo buscado deve ser explicitamente verificado usando o comando git checkout. Isso faz com que buscar uma maneira segura de revisar os commits antes de integrá-los ao seu repositório local.

Ao baixar o conteúdo de um repositório remoto, os comandos git pull e git fetch estão disponíveis para realizar a tarefa. Você pode considerar git fetch a versão 'segura' dos dois comandos. Ele fará o download do conteúdo remoto, mas não atualizará o estado de trabalho do repositório local, deixando seu trabalho atual intacto. git pull é a alternativa mais agressiva, baixará o conteúdo remoto para a ramificação local ativa e executará imediatamente git merge para criar uma confirmação de mesclagem para o novo conteúdo remoto. Se você tiver alterações pendentes em andamento, isso causará conflitos e lançará o fluxo de resolução de conflitos de mesclagem.


Com git pull:

  • Você não consegue nenhum isolamento. 
  • Isso afeta seu desenvolvimento local.
  • Não precisa ser explicitamente verificado. Porque implicitamente faz um git merge.
  • Basicamente NÃO é seguro. É agressivo.
  • Ao contrário do git fetch, onde ele afeta somente o seu .git/refs/remotes, o git pull também afeta tanto o .git/refs/remotesquanto o.git/refs/heads/.

Hmmm ... então, se eu não estou atualizando a cópia de trabalho com git fetch, então onde estou fazendo alterações? Onde o git fetch armazena os novos commits?

Ótima pergunta. Ele coloca em algum lugar isolado da sua cópia de trabalho. Mas novamente onde? Vamos descobrir.

No seu diretório de projeto (ou seja, onde você faz seus comandos gitname__): 

  1. lsname__. Isso mostrará os arquivos e diretórios. Nada legal, eu sei.

  2. Agora faça ls -a. Isto irá mostrar arquivos de ponto ou seja, arquivos que começam com . Você poderá então ver um diretório chamado: .git

  3. cd .git. Isso obviamente mudará seu diretório. 
  4. Agora vem a parte divertida; do lsname__. Você verá uma lista de diretórios. Estamos procurando refsname__. cd refs.
  5. É interessante ver o que está dentro de todos os diretórios, mas vamos nos concentrar em dois deles. headse remotesname__. Use cdpara verificar dentro deles também. 
  6. QUALQUER git fetch que você fizer atualizará os itens no diretório /.git/refs/remotes. Não atualizará nada no diretório /.git/refs/heads.
  7. QUALQUER git pull primeiro fará o git fetch, atualizará os itens no diretório /.git/refs/remotes, em seguida, mesclará com o seu local e, em seguida, alterará a cabeça dentro do diretório /.git/refs/heads

Uma resposta relacionada muito boa também pode ser encontrada Onde o 'git fetch' se posiciona?

Também procure por "notação de barra" de convenções de nomenclatura de ramificação do Git post.

1
Honey