Quais são as diferenças entre git pulle git fetch?

Nos termos mais simples, git pullfaz a git fetchseguido de a git merge.

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

Essa operação nunca altera nenhuma de suas próprias filiais locais refs/headse é segura sem alterar sua cópia de trabalho. Eu até ouvi falar de pessoas executando git fetchperiodicamente em um trabalho cron em segundo plano (embora eu não recomendo fazer isso).

A 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 :

No modo padrão, git pullé uma abreviação para git fetchseguido por git merge FETCH_HEAD.

• Quando você usa pull, o Git tenta fazer seu trabalho automaticamente para você. Como é sensível ao contexto , o Git mescla quaisquer confirmações extraídas na ramificação em que você está trabalhando. pull Mescla automaticamente as confirmações sem permitir que você as revise primeiro . Se você não gerenciar de perto suas filiais, poderá ter conflitos frequentes.

• Quando você fetch, o Git reúne quaisquer confirmações do ramo de destino que não existem no seu ramo atual e as armazena no repositório local . No entanto, ele não os mescla com sua ramificação atual . Isso é particularmente útil se você precisar manter seu repositório atualizado, mas estiver trabalhando em algo que pode quebrar se você atualizar seus arquivos. Para integrar as confirmações em sua ramificação principal, use merge.

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

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

O Git foi projetado para suportar um modelo mais distribuído, sem a necessidade de um repositório central (embora você certamente possa usá-lo, se quiser). Também o git foi projetado para que o cliente e o "servidor" não precisem estar online ao mesmo tempo. O Git foi projetado para que pessoas em um link não confiável pudessem trocar código por e-mail. É 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 reflete o estado do repositório remoto. Mantendo uma cópia do repositório remoto localmente, o git pode descobrir as alterações 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 a partir de um momento conhecido no repositório remoto.

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

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

Normalmente git pull, isso é feito git fetchpara atualizar a cópia local do repositório remoto e, em seguida, mesclar as alterações no seu próprio repositório de código e possivelmente na sua cópia de trabalho.

O problema é ter em mente que geralmente 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 consolidação. A segunda cópia é a sua cópia de trabalho onde você está editando e construindo. A terceira cópia é sua cópia local "em cache" de um repositório remoto.

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

Se houver interesse suficiente, suponho que eu poderia atualizar a imagem para adicionar git clonee git merge...

Um dos casos de uso git fetché o seguinte: qualquer alteração na ramificação remota desde o último pull ... para que você possa verificar antes de fazer um pull real, o que pode alterar os arquivos na ramificação atual e na cópia de trabalho.

git fetch
git diff ...origin

Consulte: https://git-scm.com/docs/git-diff sobre a sintaxe de pontos duplos e triplos no comando diff

Me custou um pouco entender qual era a diferença, mas essa é uma explicação simples. masterno seu host local é uma filial.

Ao clonar um repositório, você busca o repositório inteiro no host local. Isso significa que naquele momento você tem um ponteiro de origem / mestre HEADe um mestre apontando para o mesmo HEAD.

Quando você começa a trabalhar e confirma, avança o ponteiro mestre para HEAD+ confirma. 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 git fetchisso, apenas buscará todas as alterações no repositório remoto ( GitHub ) e moverá o ponteiro de origem / mestre para HEAD. Enquanto isso, o mestre da filial local continuará apontando para onde está.
• Se você fizer um git pull, ele buscará basicamente (como explicado anteriormente) e mesclará quaisquer novas alterações em sua ramificação principal e moverá o ponteiro para HEAD.

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

Brevemente

git fetché semelhante a, pullmas não é mesclado. isto é, busca atualizações remotas ( refse objects), mas seu local permanece o mesmo (ou seja, origin/masteré atualizado, mas masterpermanece o mesmo).

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

Mais

git clone clona um repositório.

git rebasesalva coisas do ramo atual que não está no ramo upstream em uma área temporária. Sua filial agora é a mesma de antes de você iniciar suas alterações. Portanto, git pull -rebasedesative as alterações remotas, rebobine sua filial local, reproduza as alterações por cima da filial atual, uma a uma, até que você esteja atualizado.

Além disso, git branch -amostrará 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 tampas git pull, git fetch, git clonee git rebase.

====

ATUALIZAR

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

1. Atualize seu repositório local a partir 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:

Na etapa 2: para obter mais informações sobre diferenças entre local e remoto, consulte: Como comparar uma ramificação git local com sua ramificação remota?

Na etapa 3: provavelmente é mais preciso (por exemplo, em um repositório que muda rapidamente) fazer um git rebase originaqui. Veja o comentário de Justin Ohms em outra resposta.

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

git-pull - Busque e mescla com outro repositório ou uma filial local
SINOPSE

git pull…
DESCRIÇÃO

Executa git-fetch com os parâmetros fornecidos e chama git-merge para mesclar o 
cabeça (s) recuperada (s) no ramo atual. Com --rebase, chama git-rebase
em vez de git-merge.

Note que você pode usar. (diretório atual) como o <repositório> a ser puxado
do repositório local - isso é útil ao mesclar ramificações locais 
no ramo atual.

Observe também que as opções destinadas ao próprio git-pull e ao git-merge subjacente 
deve ser fornecido antes das opções destinadas ao git-fetch.

Você poderia puxar se quiser que as histórias sejam mescladas e buscá-las se você apenas 'quiser o codez', pois alguma pessoa está etiquetando alguns artigos por aqui.

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

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

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

A resposta curta e fácil é que git pullé simplesmente git fetchseguida por git merge.

É muito importante observar que git pullele se fundirá automaticamente, quer você goste ou não . Obviamente, isso pode resultar em conflitos de mesclagem. Digamos que seu controle remoto seja origine seu ramo seja master. Se git diff origin/masterantes de puxar, você deve ter alguma idéia de possíveis conflitos de mesclagem e preparar sua filial local adequadamente.

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 encontra nessa situação, pode ser tentado git pull --rebase. A menos que você realmente saiba o que está fazendo, eu desaconselharia isso. Este aviso é da manpágina para git-pull, versão 2.3.5:

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

OK , aqui estão algumas informações sobre git pulle git fetch, para que você possa entender as diferenças reais ... em poucas palavras simples, a busca obtém os dados mais recentes, mas o código não muda e não mexe com o código da filial local atual, mas puxe get o código muda e mescla-o à sua filial local, continue lendo para obter mais detalhes sobre cada um:

busca do git

Ele irá baixar todos os refs e objetos e quaisquer novas agências para o seu repositório local ...

Busque ramificações e / ou tags (coletivamente, "refs") de um ou mais outros repositórios, juntamente com os objetos necessários para completar seus históricos. As ramificações de rastreamento remoto são atualizadas (consulte a descrição abaixo para obter formas de 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 os ramos nos quais você está interessado. Esse comportamento padrão pode ser alterado usando as opções --tags ou --no-tags ou configurando remote..tagOpt. Usando um refspec que busca tags explicitamente, você pode buscar tags que não apontam para ramificações nas quais você também está interessado.

O git fetch pode buscar em um único repositório ou URL nomeado ou em vários repositórios de uma só vez, se for fornecido e houver controles remotos. entrada no arquivo de configuração. (Veja git-config 1 ).

Quando nenhum controle remoto é especificado, por padrão, o controle remoto de origem será usado, a menos que haja um ramo upstream configurado para o ramo atual.

Os nomes dos árbitros buscados, 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.

puxão

Ele aplicará as alterações de remoto para o ramo atual no local ...

Incorpora alterações de um repositório remoto na ramificação atual. Em seu modo padrão, git pull é uma abreviação de git fetch seguida por git merge FETCH_HEAD.

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

deve ser o nome de um repositório remoto, conforme passado para o 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 referências 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.

Os valores padrão para e são lidos nas configurações "remota" e "mesclada" da ramificação atual, conforme definido pelo git-branch --track.

Também crio o visual abaixo para mostrar como git fetche git pulltrabalhando juntos ...

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

git fetchbasta "baixar" as alterações do controle remoto para o seu repositório local. git pullbaixa as alterações e as mescla em sua filial atual. "No modo padrão, git pullé uma abreviação para git fetchseguido por git merge FETCH_HEAD".

Bônus:

Ao falar sobre puxar e buscar nas respostas acima, gostaria de compartilhar um truque interessante,

git pull --rebase

Este comando acima é o comando mais útil na minha vida git, que economizou muito tempo.

Antes de enviar suas novas confirmações para o servidor, tente este comando e ele sincronizará automaticamente as alterações mais recentes do servidor (com uma busca + mesclagem) e colocará sua confirmação no topo do log do git. Não precisa se preocupar com puxar / mesclar manualmente.

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

Eu gosto de ter alguma representação visual da situação para entender essas coisas. Talvez outros desenvolvedores também gostem de vê-lo, então aqui está minha adição. Não tenho certeza de que tudo esteja correto, 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 das principais vantagens de obter um espelho do controle remoto são:

• Desempenho (percorra todas as confirmações e mensagens sem tentar comprimir pela rede)
• Comentários sobre o estado do seu repositório local (por exemplo, eu uso o SourceTree da Atlassian, que fornecerá uma lâmpada indicando se estou comprometido com antecedência ou atrasado em comparação com a origem. Essas informações podem ser atualizadas com um GIT FETCH).

Eu lutei com isso também. Na verdade, cheguei aqui com uma pesquisa no google exatamente da mesma pergunta. A leitura de todas essas respostas finalmente pintou uma imagem na minha cabeça e eu decidi tentar analisar o estado dos 2 repositórios e 1 sandbox e ações executadas ao longo do tempo enquanto assistia a versão deles. Então aqui está o que eu criei. Por favor, me corrija se eu errei em algum lugar.

Os três repositórios 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.

A diferença entre o GIT Fetch e o GIT Pull pode ser explicada no seguinte cenário: (Lembre-se de que as imagens falam mais alto que as palavras !, forneci representação pictórica)

Vamos dar um exemplo de que você está trabalhando em um projeto com os membros da sua equipe. Portanto, eles serão um ramo principal do projeto e todos os colaboradores deverão enviá-lo para seu próprio repositório local e, em seguida, trabalhar nesse ramo local para modificar / adicionar módulos e retornar ao ramo principal.

Portanto, o estado inicial dos dois ramos quando você bifurcou o projeto principal em seu repositório local será assim- ( A, Be Cos Módulos já estão concluídos do projeto)

Agora, você já começou a trabalhar no novo módulo (suponho D) e quando você tiver concluído o Dmódulo que deseja empurrá-lo para o ramo principal, mas enquanto isso o que acontece é que um de seus companheiros de equipe desenvolveu novo módulo E, Fe modificado C.
Então agora o que aconteceu é que seu repositório local está atrasado em relação ao progresso original do projeto e, portanto, o envio de suas alterações para o ramo principal pode levar a conflitos e causar Dmau funcionamento do seu Módulo .

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

1. Git Fetch - Isso fará o download de todas as alterações feitas no projeto de origem / filial principal que não estão presentes na filial local. E aguardará o comando Git Merge para aplicar as alterações que foram buscadas no seu Repositório ou ramo.

Agora você pode monitorar cuidadosamente os arquivos antes de mesclá-los ao seu repositório. E você também pode modificar, Dse necessário, devido a Modificado C.

2. Git Pull - Isso atualizará sua ramificação local com a ramificação origem / principal, ou seja, na verdade, o que faz é uma combinação de Git Fetch e Git mescladas uma após a outra. Mas isso pode causar conflitos, por isso é recomendável usar o Git Pull com uma cópia limpa.

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 na sua máquina local. Caso contrário, o código da máquina local não seria alterado sem mesclagem.

Portanto, no Git Gui, quando você busca, você precisa mesclar os dados. A busca em si não fará as alterações de código no seu local. Você pode verificar isso quando 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 fetchtransfere o código do servidor remoto para suas ramificações de rastreamento em seu repositório local. Se seu controle remoto é nomeado origin(o padrão), em seguida, esses ramos estará dentro origin/, por exemplo origin/master, origin/mybranch-123, etc. Estes não são seus ramos atuais, eles são locais cópias desses ramos do servidor.

git pullfaz um git fetchmas também mescla o código da ramificação de rastreamento em sua versão local atual dessa ramificação. Se você ainda não está pronto para essas mudanças, git fetchprimeiro.

git fetchirá recuperar filiais remotas de modo que você pode git diffou git mergelos com o ramo atual. git pullexecutará a busca no brach remoto rastreado pela ramificação atual e mesclará o resultado. Você pode usar git fetchpara verificar se há atualizações na filial remota sem a necessidade de mesclá-las à filial local.

Git Fetch

Você faz o download das alterações na ramificação local desde a origem até a busca. Buscar solicita ao repositório remoto todas as confirmações feitas por outras pessoas, mas você não o possui no repositório local. A busca baixa esses commits e os adiciona ao repositório local.

Git Merge

Você pode aplicar as alterações baixadas por meio da busca usando o comando mesclar. A mesclagem pega os commits recuperados da busca e tenta adicioná-los à sua filial local. A mesclagem manterá o histórico de consolidação de suas alterações locais, para que, quando você compartilhar sua ramificação com o push, o Git saberá como outras pessoas podem mesclar suas alterações.

Git Pull

A busca e a mesclagem são executadas juntas o suficiente para que um comando que combine os dois pull seja criado. Pull faz uma busca e, em seguida, uma mesclagem para adicionar as confirmações baixadas em sua filial local.

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

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

git fetch busca apenas a partir da ramificação remota, mas não é mesclada

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

Em termos simples, se você estava prestes a subir em um avião sem conexão com a Internet ... antes de partir, você poderia simplesmente fazê-lo git fetch origin <master>. Seria buscar todas as alterações no seu computador, mas mantê-lo separado do seu desenvolvimento / espaço de trabalho local.

No avião, você pode fazer alterações no espaço de trabalho local e mesclá-lo com o que buscou e resolver possíveis conflitos de mesclagem, tudo sem uma conexão com a Internet. E, a menos que alguém tenha feito novas alterações conflitantes no repositório remoto, depois que você chegar ao destino, você fará git push origin <branch>o café.

Neste incrível tutorial Atlassian :

O git fetchcomando baixa confirmações, arquivos e refs de um repositório remoto no seu repositório local.

Buscar é o que você faz quando deseja ver o que todo mundo está trabalhando. É semelhante à atualização do SVN, pois permite ver como o histórico central progrediu, mas não o força a realmente mesclar as alterações no seu repositório. O Git isola o conteúdo buscado do conteúdo local existente , não tem absolutamente nenhum efeito no seu trabalho de desenvolvimento local . O conteúdo buscado deve ser retirado explicitamente usando o git checkoutcomando Isso torna a busca de uma maneira segura de revisar confirmações antes de integrá-las ao seu repositório local.

Ao fazer o download de conteúdo de um repositório remoto, git pulle git fetchcomandos estão disponíveis para realizar a tarefa. Você pode considerar git fetcha 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 intacto o trabalho atual. git pullé a alternativa mais agressiva, ele fará o download do conteúdo remoto para a ramificação local ativa e executará imediatamente git mergepara criar uma confirmação de mesclagem para o novo conteúdo remoto. Se houver alterações pendentes em andamento, isso causará conflitos e iniciará o fluxo de resolução de conflitos de mesclagem.

Com git pull:

• Você não recebe nenhum isolamento.
• Isso afeta o seu desenvolvimento local.
• Não precisa ser explicitamente verificado. Porque implicitamente faz a git merge.
• Basicamente, NÃO é seguro. É agressivo.
• Diferente de git fetchonde isso afeta apenas o seu .git/refs/remotes, o git pull afetará tanto o seu .git/refs/remotes como .git/refs/heads/

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

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

No diretório do seu projeto (ou seja, onde você executa seus gitcomandos), faça:

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

2. Agora faça ls -a. Isto irá mostrar os arquivos de ponto , ou seja, os arquivos começando com .então você vai ser capaz de ver um diretório chamado: .git.

3. Faça cd .git. Obviamente, isso mudará seu diretório.
4. Agora vem a parte divertida; faça ls. Você verá uma lista de diretórios. Estamos procurando refs. Faça cd refs.
5. É interessante ver o que está dentro de todos os diretórios, mas vamos nos concentrar em dois deles. headse remotes. Use cdpara verificar dentro deles também.
6. Tudo o git fetch que você fizer atualizará itens no /.git/refs/remotesdiretório Não atualizará nada no /.git/refs/headsdiretório.
7. Qualquer git pull um primeiro fará os git fetchitens de atualização no /.git/refs/remotesdiretório, depois se fundirá com o seu local e depois mudará a cabeça dentro do /.git/refs/headsdiretório.

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

Além disso, procure "Notação de barra" na publicação das convenções de nomenclatura do ramo Git . Ajuda a entender melhor como o Git coloca as coisas em diretórios diferentes.

Para ver a diferença real

Apenas faça:

git fetch origin master
git checkout master

Se o mestre remoto foi atualizado, você receberá uma mensagem como esta:

Your branch is behind 'origin/master' by 2 commits, and can be fast-forwarded.
  (use "git pull" to update your local branch)

Se você não fez fetche acabou de fazer git checkout master, seu git local não saberia que existem dois commits adicionados. E diria apenas:

Already on 'master'
Your branch is up to date with 'origin/master'.

Mas isso está desatualizado e incorreto. É porque o git fornecerá feedback apenas com base no que ele sabe. É inconsciente de novos commits que ainda não foram eliminados ...

Existe alguma maneira de ver as novas alterações feitas no controle remoto enquanto trabalha na filial localmente?

Alguns IDEs (por exemplo, Xcode) são super inteligentes e usam o resultado de a git fetche podem anotar as linhas de código que foram alteradas no ramo remoto do seu ramo de trabalho atual. Se essa linha tiver sido alterada por alterações locais e ramificação remota, essa linha será anotada em vermelho. Este não é um conflito de mesclagem. É um potencial conflito de mesclagem. É um heads-up que você pode usar para resolver o futuro conflito de mesclagem antes de fazer a git pullpartir da ramificação remota.

Dica divertida:

Se você buscou uma ramificação remota, por exemplo:

git fetch origin feature/123

Então isso entraria no diretório de controles remotos. Ainda não está disponível no seu diretório local. No entanto, simplifica seu checkout para essa filial remota com DWIM (faça o que eu quero dizer):

git checkout feature/123

você não precisa mais fazer:

git checkout -b feature/123 origin/feature/123

Para mais informações, leia aqui

O Git permite que as confirmações cronologicamente mais antigas sejam aplicadas após as confirmações mais recentes. Por esse motivo, o ato de transferir confirmações entre repositórios é dividido em duas etapas:

1. A cópia de novas confirmações da ramificação remota para cópia dessa ramificação remota dentro do repositório local.

   (operação de recompra a recompra) master@remote >> remote/origin/master@local

2. Integrando novas confirmações à filial local

   (operação de repo) remote/origin/master@local >> master@local

Há duas maneiras de executar a etapa 2. Você pode:

1. Bifurque a ramificação local após o último ancestral comum e inclua novas confirmações paralelas às confirmações exclusivas do repositório local, finalizadas pela fusão da confirmação e fechando a bifurcação.
2. Inserir novas confirmações após o último ancestral comum e reaplicar confirmações exclusivas ao repositório local.

Na gitterminologia, a etapa 1 é git fetch, a etapa 2 é git mergeougit rebase

git pullé git fetchegit merge

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

1. git fetch: O Git obterá a versão mais recente do remoto para o local, mas não será mesclada automaticamente.      git fetch origin master git log -p master..origin/master git merge origin/master

        Os comandos acima significam que baixe a versão mais recente da ramificação principal da origem da ramificação mestre remota para a origem. E, 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 se unirá ao local.

       git pull origin master

        O comando acima é equivalente a git fetche git merge. Na prática, git fetchtalvez mais seguro, porque antes da mesclagem podemos ver as alterações e decidir se a mescla.

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

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

git fetchatualiza sua cópia local do repositório remoto. Por exemplo, se o seu repositório remoto for GitHub - convém buscar as alterações feitas no repositório remoto na sua cópia local do repositório remoto. Isso permitirá que você execute 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 pullvocê fará o git fetchprimeiro para atualizar a cópia local do repositório remoto e, em seguida, mesclará as alterações no seu próprio repositório de código e possivelmente na sua cópia de trabalho.

git pull == (busca do git + fusão do git)

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

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

Tentando ser claro e simples.

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

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

aqui,

git pull  

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

mas em ,

busca do git

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

por exemplo: eu vou buscar no servidor master e rebase no meu mestre local.

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

git pull origin master

aqui origem é o seu repo master remoto é sua filial

2) git fetch (necessidade de rebase manualmente):

git fetch origin master

ele buscará as alterações do servidor de origem. e ele estará no seu local até que você o refaça por conta própria. precisamos corrigir conflitos manualmente verificando códigos.

git rebase origin/master

isso irá refazer o código em local. antes disso, verifique se você está no ramo certo.

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 outra pessoa pode ter feito algumas alterações no código e você deseja manter-se atualizado.

O comando git pulltraz as alterações no repositório remoto para onde você mantém seu próprio código. Normalmente, git pullisso é feito primeiro 'git fetch' para atualizar a cópia local do repositório remoto e, em seguida, mescla as alterações no seu próprio repositório de código e possivelmente na sua cópia de trabalho.