Arasındaki farklar nelerdir git pullve git fetch?

En basit anlamda, git pullbir yok git fetchbir takip git merge.

git fetchUzaktan izleme dallarınızı altında güncellemek için istediğiniz zaman bir yapabilirsiniz refs/remotes/<remote>/.

Bu işlem hiçbir zaman kendi yerel şubelerinizi refs/headsdeğiştirmez ve çalışma kopyanızı değiştirmeden yapmak güvenlidir. Hatta git fetcharka planda bir cron işinde periyodik olarak çalışan insanlar duydum (her ne kadar bunu tavsiye etmem).

A git pull, yerel bir şubeyi uzak sürümü ile güncel hale getirmek ve aynı zamanda diğer uzaktan izleme dallarınızı güncellemek için yapacağınız şeydir.

Git belgeleri - Git Pull :

Varsayılan modda, git pulliçin kısaltmadır git fetchizledi git merge FETCH_HEAD.

• Kullandığınızda pullGit işinizi sizin için otomatik olarak yapmaya çalışır. Bağlama duyarlıdır , bu nedenle Git şu anda çalışmakta olduğunuz dalda pull alınan tüm taahhütleri birleştirir . İlk önce gözden geçirmenize izin vermeden taahhütleri otomatik olarak birleştirir . Şubelerinizi yakından yönetmiyorsanız, sık sık çatışmalarla karşılaşabilirsiniz.

• Siz fetch, Git geçerli dalınızda bulunmayan hedef daldan herhangi bir taahhüt toplar ve bunları yerel havuzunuzda depolar . Ancak, onları mevcut şubenizle birleştirmez . Bu, deponuzu güncel tutmanız gerektiğinde, ancak dosyalarınızı güncellediğinizde kırılabilecek bir şey üzerinde çalışıyorsanız özellikle yararlıdır. Taahhütleri ana dalınıza entegre etmek için kullanın merge.

Git'in tasarım felsefesini SVN gibi daha geleneksel bir kaynak kontrol aracının felsefesi ile karşılaştırmak önemlidir.

Subversion bir istemci / sunucu modeli ile tasarlanmış ve üretilmiştir. Sunucu olan tek bir havuz var ve birkaç istemci sunucudan kod getirebilir, üzerinde çalışabilir, daha sonra sunucuya geri gönderebilir. Varsayım, istemcinin bir işlem gerçekleştirmesi gerektiğinde sunucuyla her zaman iletişim kurabileceğidir.

Git, merkezi bir depoya ihtiyaç duymadan daha dağıtılmış bir modeli desteklemek için tasarlanmıştır (ancak isterseniz kesinlikle kullanabilirsiniz). Ayrıca git, istemci ve "sunucu" nın aynı anda çevrimiçi olması gerekmeyecek şekilde tasarlanmıştır. Git, güvenilir olmayan bir bağlantıdaki kişilerin bile e-posta yoluyla kod alışverişinde bulunabileceği şekilde tasarlanmıştır. Git bağlantısı ile kodun değiştirilmesi için tamamen bağlantısı kesilmiş olarak çalışmak ve CD yazmak mümkündür.

Git bu modeli desteklemek için kodunuzla birlikte yerel bir deposu ve uzak deponun durumunu yansıtan ek bir yerel deposu tutar. Uzak deponun bir kopyasını yerel olarak tutarak git, uzak depoya erişilemese bile gerekli değişiklikleri bulabilir. Daha sonra değişiklikleri başkasına göndermeniz gerektiğinde, git bunları uzak depo tarafından bilinen bir zaman diliminden bir dizi değişiklik olarak aktarabilir.

• git fetch "Uzak deponun yerel kopyamı güncelle" yazan komuttur.

• git pull "Uzak depodaki değişiklikleri kendi kodumu sakladığım yere getir" diyor.

Normalde , uzak deponun yerel kopyasını güncelleştirmek için git pulla yaparak git fetchve değişiklikleri kendi kod deponuzla ve muhtemelen çalışma kopyanızla birleştirerek bunu yapar.

Paketin kaldırılması, iş istasyonunuzda genellikle bir projenin en az üç kopyasının bulunduğunu unutmayın. Bir kopya, kendi taahhüt geçmişinize sahip kendi havuzunuzdur. İkinci kopya, düzenlediğiniz ve oluşturduğunuz çalışma kopyanızdır. Üçüncü kopya, uzak bir deponun yerel "önbelleğe alınmış" kopyasıdır.

İşte tüm Tümünün birlikte nasıl Oliver Steele resim :

Yeterli ilgi varsa, ben eklemek için görüntüyü güncellemek herhalde git cloneve git merge...

Bunun bir kullanım durumu git fetch, aşağıdakilerin son çekmenizden bu yana uzak dalda herhangi bir değişiklik söyleyeceğidir ... böylece geçerli dalınızdaki ve çalışan kopyanızdaki dosyaları değiştirebilecek gerçek bir çekmeden önce kontrol edebilirsiniz.

git fetch
git diff ...origin

Diff komutunda çift ve üçlü nokta sözdizimi ile ilgili olarak bkz. Https://git-scm.com/docs/git-diff

Aradaki farkın ne olduğunu anlamak bana biraz pahalıya mal oldu, ama bu basit bir açıklama. masterlocalhost'unuzda bir dal var.

Bir depoyu klonladığınızda, tüm depoyu yerel ana makinenize alırsınız. Bu, o sırada bir başlangıç ​​/ ana işaretçiniz olduğu HEADve aynı noktayı gösteren ana verileriniz olduğu anlamına gelir HEAD.

çalışmaya başladığınızda ve yaptığınız zaman ana işaretçiyi HEAD+ taahhütlerinize ilerletirsiniz . Ancak başlangıç ​​/ ana işaretçi hala klonladığınızda ne olduğunu gösteriyor.

Fark şu olacaktır:

• Bunu yaparsanız git fetch, uzak depodaki ( GitHub ) tüm değişiklikleri alır ve başlangıç ​​/ ana işaretçisini konumuna taşır HEAD. Bu arada yerel şube kaptanınız bulunduğu yere işaret etmeye devam edecektir.
• Bir yaparsanız git pull, temel olarak getirilir (daha önce açıklandığı gibi) ve ana dalınızdaki yeni değişiklikleri birleştirir ve işaretçiyi konumuna taşır HEAD.

Bazen görsel bir temsil yardımcı olur.

kısaca

git fetchbenzer pullancak birleşmez. yani uzaktan güncellemeleri getirir ( refsve objects) ancak yereliniz aynı kalır (yani origin/mastergüncellenir ancak masteraynı kalır).

git pull uzaktan kumandadan aşağı çeker ve anında birleşir.

Daha

git clone bir repo klonlar.

git rebasemevcut şubenizden akış yukarı şubede olmayan şeyleri geçici bir alana kaydeder. Şubeniz artık değişikliklerinizi başlatmadan önceki ile aynı. Böylece, git pull -rebaseuzaktan değişiklikleri aşağı çeker, yerel şubenizi geri sarar, güncel olana kadar değişikliklerinizi mevcut şubenizin üstünden tek tek oynatır.

Ayrıca, git branch -atüm şubelerinizde neler olduğunu tam olarak gösterecektir - yerel ve uzak.

Bu blog yayını faydalı oldu:

Git pull, git fetch ve git clone (ve git rebase) arasındaki fark - Mike Pearce

ve kapaklar git pull, git fetch, git cloneve git rebase.

====

GÜNCELLEME

Pratikte bunu nasıl kullanacağınızı göstermek için bunu güncelleyeceğimi düşündüm.

1. Yerel repo'nuzu uzaktan kumandadan güncelleyin (ancak birleştirmeyin):

   git fetch 
   

2. Güncellemeleri indirdikten sonra, farkları görelim:

   git diff master origin/master 
   

3. Bu güncellemelerden memnunsanız birleştirin:

   git pull
   

Notlar:

Adım 2: Yerel ve uzaktan kumandalar arasındaki farklar hakkında daha fazla bilgi için, bkz: Yerel git dalını uzak dalıyla nasıl karşılaştırırım?

3. adımda: Burada yapmak muhtemelen daha doğrudur (örneğin hızlı değişen bir repoda) git rebase origin. Başka bir cevapta @Justin Ohms yorumuna bakın .

Ayrıca bakınız: http://longair.net/blog/2009/04/16/git-fetch-and-merge/

git-pull - Başka bir havuzdan veya yerel bir şubeden getirme ve bir şubeyle birleştirme
ÖZET

git pull…
AÇIKLAMA

Git-fetch komutunu verilen parametrelerle çalıştırır ve birleştirmek için git-merge komutunu çağırır. 
geçerli dal içine kafa (lar) getirildi. --Rebase ile git-rebase'i çağırır
git-merge yerine.

Kullanabileceğinizi unutmayın. (geçerli dizin) çekmek için <repository> olarak
yerel depodan - bu, yerel şubeleri birleştirirken yararlıdır 
mevcut şubeye.

Ayrıca seçeneklerin git-pull'un kendisi ve altta yatan git-merge için olduğunu unutmayın 
git-fetch için kullanılan seçeneklerden önce verilmelidir.

Geçmişlerin birleştirilmesini istiyorsanız, sadece bazılarının buradaki bazı makaleleri etiketlediği için 'codez'ı istiyorsanız' çekersiniz.

Uzak bir depodan getirebilir, farkları görebilir ve ardından çekebilir veya birleştirebilirsiniz.

Bu, uzak origindalı denilen uzak bir depoya ve masteruzak dalı izleme olarak adlandırılan bir dalı için bir örnektir origin/master:

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

Kısa ve kolay cevap, bunu git pullbasitçe git fetchizler git merge.

Bu notu için çok önemlidir git pullolacaktır otomatik olarak sizin olsun ya da değil gibi birleştirme . Bu elbette birleşme çatışmalarına yol açabilir. Diyelim ki uzaktan kumandanız originve dalınız master. Eğer varsa git diff origin/masterönce çekerek, potansiyel birleştirme çatışmaların fikir sahibi olmalı ve buna göre yerel şube hazırlamak olabilir.

Çekme ve itme ek olarak, bazı iş akışları dahil git rebasebu tür bir bağlantılı makale tefsir bu gibi bir takım:

git pull origin master
git checkout foo-branch
git rebase master
git push origin foo-branch

Kendinizi böyle bir durumda bulursanız, cazip olabilirsiniz git pull --rebase. Gerçekten ne yaptığını gerçekten bilmiyorsan, buna karşı tavsiyede bulunacağım. Bu uyarı, mansayfanın git-pullsürümü için 2.3.5:

Bu, potansiyel olarak tehlikeli bir çalışma modudur. Geçmişi yeniden yazar, ki bu geçmişi zaten yayınladığınızda iyi bir şekilde işaretlenmez. Git-rebase (1) 'i dikkatle okumadığınız sürece bu seçeneği kullanmayın.

Tamam , burada hakkında bazı bilgiler vardır git pullve git fetch, sen kaç basit deyişle gerçek farklılıkları ... anlayabilmeleri getirme son verileri alır, ancak kod değişiklikleri ve geçerli yerel şube koduyla karmaşa gitmiyor ama çekme olsun kod değişir ve yerel şubenizle birleştirilir, her biri hakkında daha fazla bilgi almak için okumaya devam edin:

git getir

Tüm referansları ve nesneleri ve yeni şubeleri yerel Deponuza indirecektir ...

Geçmişlerini tamamlamak için gerekli nesnelerle birlikte bir veya daha fazla havuzdan şubeleri ve / veya etiketleri (topluca "refs") getirin. Uzaktan izleme dalları güncellenir (bu davranışı kontrol etmenin yolları için aşağıdaki açıklamaya bakın).

Varsayılan olarak, getirilen geçmişlere işaret eden herhangi bir etiket de getirilir; sonuç, ilgilendiğiniz dallara işaret eden etiketleri getirmektir. Bu varsayılan davranış, --tags veya --no-tags seçenekleri kullanılarak veya remote..tagOpt yapılandırılarak değiştirilebilir. Etiketleri açıkça alan bir refspec kullanarak, ilgilendiğiniz dallara işaret etmeyen etiketleri de getirebilirsiniz.

git fetch, verilen tek bir depodan veya URL'den ya da verilmişse ve uzaktan kumandalar varsa aynı anda birkaç havuzdan getirilebilir. yapılandırma dosyasına giriş. (Bkz. Git-config 1 ).

Hiçbir uzaktan kumanda belirtilmediğinde, geçerli dal için yapılandırılmış bir yukarı akış dalı yoksa, varsayılan olarak başlangıç ​​uzaktan kumandası kullanılır.

Alınan refs adları, işaret ettikleri nesne adlarıyla birlikte .git / FETCH_HEAD'e yazılır. Bu bilgiler komut dosyaları veya git-pull gibi diğer git komutları tarafından kullanılabilir.

git çekme

Bu değişiklikleri uygulayacaktır uzak için geçerli dalı yerel ...

Uzak bir depodaki değişiklikleri geçerli şubeye dahil eder. Varsayılan modunda git çekme git getirme için kısayoldur, ardından git birleştirme FETCH_HEAD'dir.

Daha kesin olarak, git pull verilen parametreler ile git fetch komutunu çalıştırır ve alınan dal kafalarını geçerli dalda birleştirmek için git merge komutunu çağırır. --Rebase ile git merge yerine git rebase komutunu çalıştırır.

git-fetch 1'e iletildiği şekliyle uzak bir deponun adı olmalıdır . isteğe bağlı bir uzaktan ref (örneğin, bir etiketin adı) veya hatta karşılık gelen uzaktan izleme şubelerine (örneğin, refs / heads / : refs / remotes / origin / ) sahip bir refs koleksiyonunu adlandırabilir , ancak genellikle addır depodaki bir dalın görüntüsü.

Git-branch --track tarafından ayarlandığı şekliyle, geçerli dal için "uzak" ve "birleştirme" yapılandırmasına ilişkin varsayılan değerler ve bunlar okunur.

Ayrıca nasıl ve birlikte çalışacağınızı göstermek için aşağıdaki görselleri de oluşturuyorumgit fetchgit pull

Bu etkileşimli grafik gösterim git'i anlamada çok yardımcı olur: http://ndpsoftware.com/git-cheatsheet.html

git fetchuzaktan kumandadan yerel deponuza değişiklikleri "indirir". git pulldeğişiklikleri indirir ve mevcut dalınızla birleştirir. git pullMsgstr "Varsayılan modda kısayol git fetchizler git merge FETCH_HEAD."

Bonus:

Yukarıdaki cevaplarda çekme ve getirme konuşmasında, ilginç bir hile paylaşmak istiyorum,

git pull --rebase

Bu yukarıdaki komut git hayatımda çok zaman kazandıran en kullanışlı komuttur.

Yeni taahhütlerinizi sunucuya aktarmadan önce, bu komutu deneyin; en son sunucu değişikliklerini (getirme + birleştirme ile) otomatik olarak senkronize eder ve git günlüğünde taahhüdünüzü en üste yerleştirir. Manuel çekme / birleştirme konusunda endişelenmenize gerek yok.

Ayrıntıları şu adreste bulabilirsiniz: http://gitolite.com/git-pull--rebase

Bu şeyleri kavramak için durumun görsel temsilini seviyorum. Belki diğer geliştiriciler de görmek ister, işte benim ekim. Her şeyin doğru olduğundan emin değilim, bu yüzden herhangi bir hata bulursanız lütfen yorum yapın.

                                         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.

Uzaktan kumandanın getirilmiş aynasına sahip olmanın bazı önemli avantajları şunlardır:

• Performans (ağ üzerinden sıkıştırmaya çalışmadan tüm işlemlerde ve mesajlarda ilerleyin)
• Yerel deponuzun durumu hakkında geri bildirim (örneğin, Atlassian'ın SourceTree'ini kullanıyorum, bu da bana orijin ile karşılaştırıldığında önde veya arkada olup olmadığımı gösteren bir ampul verecek. Bu bilgiler bir GIT FETCH ile güncellenebilir).

Ben de bununla mücadele ettim. Aslında tam olarak aynı sorunun bir Google aramasıyla buraya geldim. Tüm bu cevapları okuduktan sonra kafamda bir resim çizdim ve bunu 2 havuzu ve 1 sandbox'ın durumunu ve zaman içinde yapılan eylemleri izlerken onları indirmeye karar verdim. İşte benim ortaya koyduğum şey. Herhangi bir yere bulaşırsam lütfen beni düzeltin.

Getirilen üç depo:

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

Çekili üç depo

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

Bu, getirmenin neden oldukça önemli olduğunu anlamama yardımcı oldu.

GIT Fetch ve GIT Pull arasındaki fark aşağıdaki senaryo ile açıklanabilir: (Resimlerin kelimelerden daha yüksek sesle konuştuğunu unutmayın !, Resimli temsil sağladım)

Ekip üyelerinizle bir proje üzerinde çalıştığınıza bir örnek verelim. Bu yüzden projenin bir ana kolu olacaklar ve tüm katkıda bulunanlar onu kendi yerel havuzuna yerleştirmeli ve daha sonra modülleri değiştirmek / eklemek için bu yerel şube üzerinde çalışmalı ve ana şubeye geri dönmelidir.

Yani, ilk Devlet iki Şube Eğer bu- gibi olacak yerel depo ana projeyi çatallı zaman ( A, Bve CModüller zaten projenin tamamlanan)

Şimdi, yeni modül (varsayalım üzerinde çalışmaya başladık D) ve tamamladığınızda Dana dalına itin istediğiniz modülü, Fakat bu arada ne olur takım arkadaşları yeni bir Modülü geliştirdi olmasıdır E, Fve modifiye C.
Şimdi olan şey, yerel deponuzun projenin orijinal ilerlemesinin gerisinde kalması ve bu nedenle değişikliklerinizin ana şubeye itilmesi çatışmaya yol açabilir ve Modülünüzün Darızalanmasına neden olabilir .

Bu tür sorunları önlemek ve projenin orijinal ilerlemesine paralel çalışmak için iki yol vardır:

1. Git Getir- Bu, yerel şubenizde bulunmayan başlangıç ​​/ ana şube projesinde yapılan tüm değişiklikleri indirir . Git Birleştirme komutunun Deponuza veya şubenize getirilen değişiklikleri uygulaması için bekler.

Şimdi dosyaları deponuzla birleştirmeden önce dikkatlice izleyebilirsiniz. Ayrıca D, Değiştirildi nedeniyle gerekirse de değiştirebilirsiniz C.

2. Git Pull- Bu, yerel dalınızı başlangıç ​​noktası / ana dal ile güncelleyecektir, yani yaptığı şey Git Fetch ve Git'in birbiri ile birleşmesidir. Ancak bu Çatışmaların ortaya çıkmasına neden olabilir, bu nedenle Git Pull'u temiz bir kopya ile kullanmanız önerilir.

Basitçe diyoruz:

git pull == git fetch + git merge

Çalıştırırsanız git pull, verileri yerel ile birleştirmeniz gerekmez. Eğer koşarsan git fetch, koşmalısıngit merge yerel makinenize en son kodu almak için . Aksi takdirde, yerel makine kodu birleştirme olmadan değiştirilmez.

Git Gui'de, getirdiğinizde verileri birleştirmeniz gerekir. Getirmenin kendisi yerelde kod değişiklikleri yapmaz. Kodu bir kez getirip gördüğünüzde kodu güncellediğinizde kontrol edebilirsiniz; kod değişmeyecek. Sonra birleştirirsiniz ... Değiştirilen kodu göreceksiniz.

git fetchkodu uzak sunucudan yerel deponuzdaki izleme şubelerinize indirir. Uzaktan adlı edilirse origin(varsayılan) daha sonra bu dallar içinde olacak origin/, örneğin origin/master, origin/mybranch-123vb Bunlar mevcut dallar değildir, bunlar yerel sunucudan bu dalların kopyaları.

git pullBir yapar git fetchama sonra da bu dalın mevcut yerel sürümüne takip dalından kodu birleştirir. Henüz bu değişikliklere hazır değilseniz, git fetchilk önce.

git fetchUzak dalları alır yapabilirsiniz, böylece git diffveya git mergeşimdiki şube ile onları. git pullgetirmeyi geçerli dal tarafından izlenen uzak brakette çalıştırır ve ardından sonucu birleştirir. git fetchUzak dalda yerel dalınızla birleştirmeden gerekli güncellemelerin olup olmadığını görmek için kullanabilirsiniz .

Git Getir

Yerel şubenizdeki değişiklikleri başlangıç ​​noktasından getirmeye indirirsiniz. Getir, uzak repodan başkalarının yaptığı tüm taahhütleri sorar, ancak yerel repoda bulunmaz. Getir bu taahhütleri indirir ve yerel veri havuzuna ekler.

Git Merge

Birleştirme komutunu kullanarak getirme yoluyla indirilen değişiklikleri uygulayabilirsiniz. Birleştirme, getirme işleminden alınan taahhütleri alır ve bunları yerel şubenize eklemeye çalışır. Birleştirme, yerel değişikliklerin taahhüt geçmişini koruyacak, böylece şubenizi push ile paylaştığınızda, başkalarının değişikliklerinizi nasıl birleştirebileceğini bilecektir.

Git Pull

Getirme ve birleştirme, iki çekme işlemini birleştiren bir komutun oluşturulacağı kadar sık ​​birlikte çalışır. Pull bir getirme yapar ve ardından indirilen taahhütleri yerel şubenize eklemek için birleştirme yapar.

Arasındaki tek fark git pullve git fetcholmasıdır:

git pull uzak bir daldan çeker ve birleştirir.

git fetch yalnızca uzak daldan getirilir ancak birleştirilmez

ie git pull = git getirme + git birleştirme ...

Basit bir ifadeyle, herhangi bir İnternet bağlantısı olmayan bir uçağa atlamak üzereydiniz ... ayrılmadan önce git fetch origin <master> . Tüm değişiklikleri bilgisayarınıza getirir, ancak yerel geliştirme / çalışma alanınızdan ayrı tutar.

Uçakta, yerel çalışma alanınızda değişiklikler yapabilir ve daha sonra getirdiğiniz şeyle birleştirebilir ve olası birleştirme çakışmalarını Internet bağlantısı olmadan çözebilirsiniz. Birisi uzak depoda yeni çelişkili değişiklikler yapmamışsa , o zaman hedefe vardığınızda git push origin <branch>kahvenizi alırsınız.

Bu harika Atlassian öğreticisinden :

git fetchYerel depoya uzak deposundan komut indirme kaydedilmesini, dosyalar ve ref.

Getirme, diğer herkesin ne üzerinde çalıştığını görmek istediğinizde yaptığınız şeydir . Merkezi geçmişin nasıl ilerlediğini görmenize izin vermesi SVN güncellemesine benzer, ancak değişiklikleri gerçekte deponuzda birleştirmeye zorlamaz. Git getirilen içeriği mevcut yerel içerikten ayırır , yerel geliştirme çalışmalarınız üzerinde kesinlikle hiçbir etkisi yoktur . Alınan içeriğin git checkoutkomut kullanılarak açıkça kontrol edilmesi gerekir . Bu, getirmeleri yerel deponuza entegre etmeden önce taahhütleri gözden geçirmenin güvenli bir yolunu yapar.

Uzak bir depo içerik indirmeye, zaman git pullve git fetchkomutlar görevi başarmak için kullanılabilir. git fetchİki komutun 'güvenli' sürümünü düşünebilirsiniz . Uzak içeriği indirir, ancak yerel deponuzun çalışma durumunu güncellemez ve mevcut çalışmanızı olduğu gibi bırakır.git pulldaha agresif bir alternatifse, etkin yerel şube için uzak içeriği indirecek git mergeve yeni uzak içerik için birleştirme taahhüdü oluşturmak üzere hemen yürütecektir . Devam etmekte olan değişiklikleriniz varsa, bu çatışmalara neden olur ve birleşme çakışması çözüm akışını başlatır.

İle git pull :

• Hiçbir izolasyonunuz yok.
• Yerel gelişiminizi etkiler.
• Açıkça kontrol edilmesi gerekmez. Çünkü dolaylı olarak birgit merge .
• Temelde güvenli değil. Saldırgan.
• Aksine git fetcho yalnızca etkiler nerede .git/refs/remotes, git çekme etkileyecek hem sizin .git/refs/remotes ve .git/refs/heads/

Hmmm ... eğer çalışan kopyayı güncellemiyorsam git fetch nerede değişiklikler yapıyorum? Git getirme yeni taahhütleri nerede saklar?

Harika bir soru. Çalışma kopyanızdan yalıtılmış bir yere koyar. Ama yine nerede? Hadi bulalım.

Proje dizininizde (yani, gitkomutlarınızı yaptığınız yerde ):

1. ls. Bu, dosyaları ve dizinleri gösterecektir. Güzel bir şey yok, biliyorum.

2. Şimdi yap ls -a. Bu nokta dosyalarını gösterecektir , yani .Sizin ile başlayan dosyalar : adlı bir dizini görebilecektir .git.

3. Yapmak cd .git . Bu kesinlikle dizininizi değiştirecektir.
4. Şimdi eğlenceli kısım geliyor; yapın ls. Dizinlerin bir listesini göreceksiniz. Biz arıyoruz refs. Yap cd refs.
5. Tüm dizinlerin içinde ne olduğunu görmek ilginç, ama ikisine odaklanalım. headsve remotes. İçlerini cdde kontrol etmek için kullanın .
6. Yaptığınız git fetch her şey /.git/refs/remotesdizindeki öğeleri güncelleyecektir . /.git/refs/headsDizindeki hiçbir şeyi güncellemez .
7. Herhangi git pull ilk yapacak git fetch, güncelleme öğeleri içinde /.git/refs/remotesdizine, sonra yerel ile birleştirme ve ardından iç kafasını değiştirmek /.git/refs/headsdizinde.

'Git getirme' kendini nerede yerleştirir? Bölümünde çok iyi bir ilgili cevap da bulunabilir. .

Ayrıca Git dalı adlandırma kuralları gönderisinde "Eğik çizgi işareti" konusuna bakın . Git'in işleri farklı dizinlere nasıl yerleştirdiğini daha iyi anlamanıza yardımcı olur.

Gerçek farkı görmek için

Sadece yap:

git fetch origin master
git checkout master

Uzak ana bilgisayar güncellenmişse, şöyle bir mesaj alırsınız:

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

Eğer yapmadıysanız fetchve sadece yaptıysanız git checkout master, yerel git 2 taahhüt eklendiğini bilmiyordu. Ve sadece şunu söylerdi:

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

Ama bu modası geçmiş ve yanlış. Çünkü git, yalnızca bildiklerine dayanarak size geri bildirim verecektir. Henüz indirmediği yeni taahhütlerden habersiz ...

Yerel olarak şube üzerinde çalışırken uzaktan yapılan yeni değişiklikleri görmenin bir yolu var mı?

Bazı IDE'ler (örn. Xcode) süper akıllıdır ve a'nın sonucunu kullanır ve git fetchgeçerli çalışma dalınızın uzak dalında değiştirilen kod satırlarına açıklama ekleyebilir. Bu satır hem yerel değişiklikler hem de uzak dal tarafından değiştirildiyse, bu satır kırmızı ile açıklanır. Bu birleşme çatışması değil. Bu potansiyel bir birleşme çatışmasıdır. git pullUzak daldan önce gelecekteki birleştirme çatışmasını çözmek için kullanabileceğiniz bir kafa vuruşu .

Eğlenceli ipucu:

Uzak bir dal getirdiyseniz, örneğin:

git fetch origin feature/123

Sonra bu uzaktan kumandalar dizininize gider. Yerel dizininiz tarafından kullanılamıyor. Ancak, DWIM (ne demek istediğimi yap) ile o uzak dalı için ödeme kolaylaştırır:

git checkout feature/123

artık yapmanız gerekmiyor:

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

Bununla ilgili daha fazla bilgi için burayı okuyun

Git, yeni işlemlerden sonra kronolojik olarak daha eski işlemlerin uygulanmasına izin verir. Bu nedenle, depolar arasında taahhütleri aktarma eylemi iki adıma ayrılır:

1. Uzak şubeden bu uzak şubenin yerel repo içindeki kopyasına yeni taahhütlerin kopyalanması.

   (repo işlemine repo) master@remote >> remote/origin/master@local

2. Yeni taahhütleri yerel şubeye entegre etme

   (repo operasyonu) remote/origin/master@local >> master@local

2. adımı gerçekleştirmenin iki yolu vardır.

1. Son ortak atadan sonra yerel şubeyi çatallayın ve yerel depoya özgü taahhütlere paralel olarak yeni taahhütler ekleyin, birleştirme taahhüdü ile tamamlanır, çatal kapatılır.
2. Son ortak atadan sonra yeni taahhütler ekleyin ve yerel depoya özgü taahhütleri tekrar uygulayın.

Olarak gitterminoloji, aşama 1 git fetch, aşama 2, git mergeya dagit rebase

git pullolduğu git fetchvegit merge

Git, en son sürümün dalını iki komut kullanarak uzaktan kumandadan yerel konuma alır:

1. git fetch: Git en son sürümü uzaktan kumandadan yerel konuma alacaktır, ancak otomatik olarak birleştirilmez.      git fetch origin master git log -p master..origin/master git merge origin/master

        Yukarıdaki komutlar, ana dalın en son sürümünü uzaktan kumandadan başlangıç ​​ana dalına indirmektir. Ve sonra yerel ana dalı ve kökeni ana dalı karşılaştırır. Sonunda birleştir.

2. git pull: Git en son sürümü uzaktan kumandadan alıp yerelde birleştirecek.

       git pull origin master

        Komut yukarıdaki eşdeğerdir git fetchve git merge. Uygulamada git fetchbelki daha güvenlidir çünkü birleştirme işleminden önce değişiklikleri görebilir ve birleştirilip birleştirilmeyeceğine karar verebiliriz.

Arasındaki fark nedir git pullve git fetch?

Bunu anlamak için öncelikle yerel git'inizin yalnızca yerel deponuzu değil, aynı zamanda uzak deponun yerel bir kopyasını da tuttuğunu anlamanız gerekir.

git fetchuzak deponun yerel kopyasını güncelleştirir. Örneğin, uzak deponuz GitHub ise - uzak depoda yapılan değişiklikleri yerel deponuzun uzak kopyasına almak isteyebilirsiniz. Bu karşılaştırma veya birleştirme gibi işlemleri gerçekleştirmenizi sağlar.

git pullÖte yandan uzak depodaki değişiklikleri kendi kodunuzu sakladığınız yere indirecektir. Genellikle, uzak deponun yerel kopyasını güncelleştirmek için git pullbir git fetchilk yapar ve ardından değişiklikleri kendi kod deponuzda ve muhtemelen çalışma kopyanızda birleştirir.

git pull == (git getirme + git birleştirme)

git fetch yerel şubelerde değişiklik yapmaz.

İstediğiniz proje için uzaktan ayarlanmış bir yerel havuzunuz varsa, git fetch komutunu kullanarak mevcut uzaktan kumanda için tüm dalları ve etiketleri alabilirsiniz. ... Getirme yerel şubelerde herhangi bir değişiklik yapmaz, bu nedenle yeni getirme değişikliklerini dahil etmek için uzak bir dalı eşleştirilmiş bir yerel dalla birleştirmeniz gerekir. github dan

Açık ve basit olmaya çalışıyorum.

Git çekme komutu bir aslında shortcutiçin Git getirme ardından git birleştirme veya git Rebase yapılandırmanıza bağlı olarak komuta. Git deponuzu, git pull'un bir getirme ve ardından bir rebase olacağı şekilde yapılandırabilirsiniz .

Yeni Başlayanlar İçin Basit Bir Grafiksel Temsili,

buraya,

git pull  

depodan kod getirecek ve yerelinizle yeniden başlayacak ... git pull'da yeni taahhütlerin oluşturulması olasılığı var.

ama içinde,

git getir

depodan kod getirecek ve kullanarak kodu manuel olarak yeniden oluşturmamız gerekiyor git rebase

Örneğin: sunucu yöneticisinden getireceğim ve yerel yöneticimde yeniden oluşturacağım.

1) git pull (rebase otomatik olarak yapılacaktır):

git pull origin master

burada kökeni uzak repo ustanız senin dalın

2) git getirme (manuel olarak yeniden adlandırılması gerekir):

git fetch origin master

sunucu değişikliklerini başlangıç ​​noktasından alır. ve kendi başınıza yeniden pazarlayana kadar yerelde olacak. kodları kontrol ederek çakışmaları manuel olarak düzeltmemiz gerekir.

git rebase origin/master

bu, kodu yerel olarak yeniden oluşturur. önce doğru dalda olduğunuzdan emin olun.

Aslında Git, kendi kodunuzun ve uzak deponun bir kopyasını saklar.

Komut git fetch, uzak depodan veri alarak yerel kopyanızı güncel hale getirir. Buna ihtiyacımızın nedeni, başka birinin kodda bazı değişiklikler yapmış olması ve kendinizi güncel tutmak istemenizdir.

Komut git pull, uzak depodaki değişiklikleri kendi kodunuzu sakladığınız yere getirir. Normalde, git pullbunu ilk önce uzak deponun yerel kopyasını güncellemek için bir 'git fetch' yaparak yapar ve daha sonra değişiklikleri kendi kod deponuzda ve muhtemelen çalışma kopyanızda birleştirir.