Quais são as diferenças entre git pull
e git fetch
?
git
version-control
git-pull
git-fetch
pupeno
fonte
fonte
git fetch; git reset --hard origin/master
parte do nosso fluxo de trabalho. Ele afasta as alterações locais, mantém você atualizado com o mestre, MAS garante que você não apenas puxe novas alterações por cima das alterações atuais e faça uma bagunça. Nós o usamos há um tempo e, basicamente, parece muito mais seguro na prática. Apenas certifique-se de adicionar / confirmar / esconder qualquer trabalho em andamento primeiro!Respostas:
Nos termos mais simples,
git pull
faz agit fetch
seguido de agit merge
.Você pode fazer um
git fetch
a qualquer momento para atualizar suas ramificações de rastreamento remoto emrefs/remotes/<remote>/
.Essa operação nunca altera nenhuma de suas próprias filiais locais
refs/heads
e é segura sem alterar sua cópia de trabalho. Eu até ouvi falar de pessoas executandogit fetch
periodicamente 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 :
fonte
git pull
sempre será mesclado na ramificação atual . Então, você seleciona qual ramo você quer puxar a partir de , e puxá-lo para o ramo atual. A ramificação from pode ser local ou remota; pode até ser um ramo remoto que não esteja registradogit remote
(o que significa que você passa um URL nagit pull
linha de comando)./home/alice/
e fizergit fetch /home/bob
, quais parâmetros devo passar para o subseqüentegit merge
?pull
na verdade, não pode ser emulado por um sinal defetch
mais amerge
. Acabei de buscar uma alteração na qual apenas um ponteiro de ramificação remota muda e memerge
recuso a fazer qualquer coisa.pull
, por outro lado, avança rapidamente meu ramo de rastreamento.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, usemerge
.fonte
git fetch
apenas o.git/
diretório (AKA: repositório local) e nada fora.git/
(AKA: árvore de trabalho). Ele não altera suas filiais locais e também não tocamaster
. Tocaremotes/origin/master
embora (vejagit branch -avv
). Se você tiver mais controles remotos, tentegit remote update
. Este é umgit fetch
para todos os controles remotos em um comando..git/refs/remotes/origin/
..git
? Qual é o benefício pretendido e o que devo fazer depois disso?É 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 é feitogit fetch
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.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.
fonte
remoteName/
Git desde o início, é uma leitura muito boa. Depois de entender como o Git funciona - e é realmente muito simples - tudo faz sentido.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 clone
egit merge
...fonte
git clone
egit merge
seria muito útil!git merge
- ele deve mostrar claramente que amerge
chamada separada NÃO é a mesma que a chamada,pull
porquepull
é mesclada apenas do remoto e ignora as confirmações locais na filial local, que estão rastreando a filial remota que está sendo retirada.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.Consulte: https://git-scm.com/docs/git-diff sobre a sintaxe de pontos duplos e triplos no comando diff
fonte
git diff ..origin
?git diff ...origin
é equivalente agit diff $(git-merge-base HEAD origin) origin
(consulte agit diff [--options] <commit>...<commit> [--] [<path>…]
seção kernel.org/pub/software/scm/git/docs/git-diff.html#_description ), que é diferente degit diff origin
;git diff ...origin
é conceitualmente as alterações feitasorigin
desde que a ramificação atual ramificouorigin
, enquantogit diff origin
inclui também o reverso das alterações feitas na ramificação atual desde que ramificouorigin
.git diff origin/master
obras, como mencionado abaixoMe custou um pouco entender qual era a diferença, mas essa é uma explicação simples.
master
no 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
HEAD
e um mestre apontando para o mesmoHEAD
.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á:
git fetch
isso, apenas buscará todas as alterações no repositório remoto ( GitHub ) e moverá o ponteiro de origem / mestre paraHEAD
. Enquanto isso, o mestre da filial local continuará apontando para onde está.git pull
, ele buscará basicamente (como explicado anteriormente) e mesclará quaisquer novas alterações em sua ramificação principal e moverá o ponteiro paraHEAD
.fonte
git fetch
era literalmente fazer o download das alterações no repositório remoto no seu repositório local, mas NÃO as confirme - ou seja, elas ainda precisam ser adicionadas / confirmadas no seu repositório local.Às vezes, uma representação visual ajuda.
fonte
git pull
está pulando a busca, o que obviamente é impreciso.Brevemente
git fetch
é semelhante a,pull
mas não é mesclado. isto é, busca atualizações remotas (refs
eobjects
), mas seu local permanece o mesmo (ou seja,origin/master
é atualizado, masmaster
permanece o mesmo).git pull
puxa para baixo de um controle remoto e se funde instantaneamente.Mais
git clone
clona um repositório.git rebase
salva 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 -rebase
desative 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 -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 tampas
git pull
,git fetch
,git clone
egit rebase
.====
ATUALIZAR
Eu pensei em atualizar isso para mostrar como você realmente usaria isso na prática.
Atualize seu repositório local a partir do controle remoto (mas não mescle):
Depois de baixar as atualizações, vamos ver as diferenças:
Se você estiver satisfeito com essas atualizações, mescle:
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 origin
aqui. Veja o comentário de Justin Ohms em outra resposta.Veja também: http://longair.net/blog/2009/04/16/git-fetch-and-merge/
fonte
git clone
. Eu coloquei a ponta entre aspas, como eu suponho que isso significaria tudo o mestre é e o que alguém faria "Download como zip" de github.comVocê 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.
fonte
git fetch
isso, busca alterações no repositório e atualiza sua filial remota local. Não afeta sua filial local, que rastreia a filial remota local, portanto não afeta sua cópia de trabalho. Agora, quando você faz um,merge
ele mescla as alterações buscadas com sua filial local.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
origin
e uma ramificação chamadamaster
rastreamento da ramificação remotaorigin/master
:fonte
A resposta curta e fácil é que
git pull
é simplesmentegit fetch
seguida porgit merge
.É muito importante observar que
git pull
ele se fundirá automaticamente, quer você goste ou não . Obviamente, isso pode resultar em conflitos de mesclagem. Digamos que seu controle remoto sejaorigin
e seu ramo sejamaster
. Segit diff origin/master
antes 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: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 é daman
página paragit-pull
, versão2.3.5
:fonte
git pull --rebase
não é a coisa certa em uma situação específica, é certo se for feita em duas etapas? Se é a coisa certa a fazer, qual é o benefício extra de fazê-lo em duas etapas?rebase
quando você estiver trabalhando em uma filial local ainda não enviada por push. Se você estiver trabalhando em uma filial que existe no controle remoto,rebase
pode resultar em alguns problemas desagradáveis, portanto, você deve preferir um regularmerge
.OK , aqui estão algumas informações sobre
git pull
egit 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 ...
puxão
Ele aplicará as alterações de remoto para o ramo atual no local ...
Também crio o visual abaixo para mostrar como
git fetch
egit pull
trabalhando juntos ...fonte
Essa representação gráfica interativa é muito útil para entender o git: http://ndpsoftware.com/git-cheatsheet.html
git fetch
basta "baixar" as alterações do controle remoto para o seu repositório local.git pull
baixa as alterações e as mescla em sua filial atual. "No modo padrão,git pull
é uma abreviação paragit fetch
seguido porgit merge FETCH_HEAD
".fonte
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
fonte
git pull
egit 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.
Algumas das principais vantagens de obter um espelho do controle remoto são:
fonte
git pull
Também não realiza uma mesclagem, ou seja, indo até a cópia de trabalho?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:
Os três repos com um puxão
Isso me ajudou a entender por que uma busca é muito importante.
fonte
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
,B
eC
os 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 oD
mó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óduloE
,F
e modificadoC
.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
D
mau 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,
D
se necessário, devido a ModificadoC
.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.
fonte
Simplesmente dizemos:
Se você executar
git pull
, não precisará mesclar os dados ao local. Se você executargit fetch
, isso significa que você deve executargit merge
para 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.
fonte
git pull == git fetch + git merge
:)git pull --rebase = git fetch + git rebase
git fetch
transfere o código do servidor remoto para suas ramificações de rastreamento em seu repositório local. Se seu controle remoto é nomeadoorigin
(o padrão), em seguida, esses ramos estará dentroorigin/
, por exemploorigin/master
,origin/mybranch-123
, etc. Estes não são seus ramos atuais, eles são locais cópias desses ramos do servidor.git pull
faz umgit fetch
mas 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 fetch
primeiro.fonte
git fetch
irá recuperar filiais remotas de modo que você podegit diff
ougit merge
los com o ramo atual.git pull
executará a busca no brach remoto rastreado pela ramificação atual e mesclará o resultado. Você pode usargit fetch
para verificar se há atualizações na filial remota sem a necessidade de mesclá-las à filial local.fonte
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.
fonte
A única diferença entre
git pull
egit 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 é mescladaou seja, git pull = git buscar + mesclar git ...
fonte
rm -rf
tudo e recomeçando. Git estúpido, por favor, deixe-me atualizar para que eu possa voltar ao trabalho?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 :
Com
git pull
:git merge
.git fetch
onde 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
git
comandos), faça:ls
. Isso mostrará os arquivos e diretórios. Nada legal, eu sei.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
.cd .git
. Obviamente, isso mudará seu diretório.ls
. Você verá uma lista de diretórios. Estamos procurandorefs
. Façacd refs
.heads
eremotes
. Usecd
para verificar dentro deles também.git fetch
que você fizer atualizará itens no/.git/refs/remotes
diretório Não atualizará nada no/.git/refs/heads
diretório.git pull
um primeiro fará osgit fetch
itens de atualização no/.git/refs/remotes
diretório, depois se fundirá com o seu local e depois mudará a cabeça dentro do/.git/refs/heads
diretó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:
Se o mestre remoto foi atualizado, você receberá uma mensagem como esta:
Se você não fez
fetch
e acabou de fazergit checkout master
, seu git local não saberia que existem dois commits adicionados. E diria apenas: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 fetch
e 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 agit pull
partir da ramificação remota.Dica divertida:
Se você buscou uma ramificação remota, por exemplo:
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):
você não precisa mais fazer:
Para mais informações, leia aqui
fonte
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:
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
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:
Na
git
terminologia, a etapa 1 égit fetch
, a etapa 2 égit merge
ougit rebase
git pull
égit fetch
egit merge
fonte
O Git obtém a ramificação da versão mais recente do controle remoto para o local usando dois comandos:
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.
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 fetch
egit merge
. Na prática,git fetch
talvez mais seguro, porque antes da mesclagem podemos ver as alterações e decidir se a mescla.fonte
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 fetch
atualiza 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 pull
por outro lado, derrubará as alterações no repositório remoto para onde você mantém seu próprio código. Normalmente,git pull
você fará ogit fetch
primeiro 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.fonte
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
fonte
Tentando ser claro e simples.
O comando git pull é na verdade um
shortcut
for 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.fonte
Uma representação gráfica simples para iniciantes,
aqui,
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):
aqui origem é o seu repo master remoto é sua filial
2) git fetch (necessidade de rebase manualmente):
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.
isso irá refazer o código em local. antes disso, verifique se você está no ramo certo.
fonte
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 pull
traz as alterações no repositório remoto para onde você mantém seu próprio código. Normalmente,git pull
isso é 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.fonte