Dalam istilah sederhana, git pull tidak git fetch diikuti oleh git merge.

Anda dapat melakukan git fetch setiap saat untuk memperbarui perangkat remote-cabang pelacakan di bawah ref/remote/<remote>/.

Operasi ini tidak pernah berubah anda sendiri cabang-cabang lokal di bawah ref/kepala, dan aman untuk dilakukan tanpa mengubah copy pekerjaan anda. Aku telah mendengar dari orang-orang yang menjalankan git fetch secara berkala di cron job di latar belakang (meskipun saya tidak't merekomendasikan melakukan hal ini).

A git pull apa yang akan anda lakukan untuk membawa cabang lokal up-to-date dengan remote versi, sementara juga memperbarui terpencil lainnya-cabang pelacakan.

Git dokumentasi – git pull:

Dalam mode default, git pull adalah kependekan dari git fetch diikuti oleh git merge FETCH_HEAD.

• Bila anda menggunakan menarik, Git mencoba untuk secara otomatis bekerja untuk anda. Ini adalah konteks sensitif, maka Git akan menggabungkan setiap melakukan ditarik ke cabang anda yang saat ini bekerja di. menarik secara otomatis menggabungkan melakukan tanpa membiarkan anda meninjau mereka pertama. Jika anda tidak cermat mengelola cabang-cabang anda, anda mungkin mengalami sering konflik.

• Ketika anda ambil, Git mengumpulkan setiap melakukan dari target cabang yang tidak ada pada anda saat ini cabang dan toko mereka dalam repositori lokal anda. Namun, tidak menggabungkan mereka dengan anda saat ini cabang. Hal ini sangat berguna jika anda perlu untuk membuat repositori anda up to date, tetapi bekerja pada sesuatu yang mungkin pecah jika anda memperbarui file anda. Untuk mengintegrasikan komit ke cabang master, anda menggunakan bergabung.

Hal ini penting untuk kontras filosofi desain dari git dengan filosofi yang lebih tradisional sumber alat kontrol seperti SVN.

Subversion dirancang dan dibangun dengan model client/server. Ada satu repositori yang merupakan server, dan beberapa klien dapat mengambil kode dari server, bekerja di atasnya, kemudian melakukan kembali ke server. Asumsi adalah bahwa klien selalu dapat menghubungi server pada saat dibutuhkan untuk melakukan operasi.

Git dirancang untuk mendukung lebih banyak didistribusikan model dengan tidak perlu untuk sebuah repositori pusat (meskipun tentu saja anda dapat menggunakan salah satu jika anda suka). Juga git dirancang agar klien dan "server" don't harus online pada waktu yang sama. Git dirancang agar orang-orang tidak dapat diandalkan link bisa bertukar kode melalui email, bahkan. Hal ini dimungkinkan untuk bekerja benar-benar terputus dan membakar CD untuk pertukaran kode melalui git.

Dalam rangka mendukung model ini git mempertahankan repositori lokal dengan kode anda dan juga tambahan repositori lokal yang mencerminkan keadaan remote repositori. Dengan menjaga salinan repositori lokal, git dapat mengetahui perubahan yang dibutuhkan bahkan ketika repositori jauh yang tidak terjangkau. Kemudian ketika anda perlu untuk mengirim perubahan ke orang lain, git dapat mentransfer mereka sebagai satu set dari perubahan dari satu titik dalam waktu yang dikenal untuk remote repositori.

• git fetch adalah perintah yang mengatakan "membawa saya copy lokal dari repositori jauh up to date."

• git pull kata "membawa perubahan dalam repositori jauh untuk di mana aku menjaga diriku sendiri kode."

Biasanya git pull ini dengan melakukan git fetch untuk membawa salinan lokal dari repositori jauh up to date, dan kemudian menggabungkan perubahan ke dalam repositori kode dan mungkin copy pekerjaan anda.

Yang mengambil adalah untuk menjaga dalam pikiran bahwa sering ada setidaknya tiga salinan proyek pada workstation anda. Satu salinan anda sendiri repositori dengan anda sendiri komit sejarah. Salinan kedua adalah copy pekerjaan anda di mana anda mengedit dan bangunan. Ketiga salinan lokal anda "cache" salinan repositori jauh.

Berikut ini adalah Oliver Steele's gambar dari bagaimana semua itu cocok bersama-sama:

Jika ada bunga yang cukup, saya kira saya bisa memperbarui gambar untuk menambahkan git clone dan git merge...

Salah satu kasus penggunaan git fetch` adalah yang berikut ini akan memberitahu anda setiap perubahan dalam remote branch sejak terakhir anda tarik... sehingga anda dapat memeriksa sebelum melakukan hal yang sebenarnya menarik, yang bisa mengubah file anda saat ini, cabang dan kerja copy.

git fetch
git diff ...origin

Lihat: https://git-scm.com/docs/git-diff mengenai double dan triple-dot sintaks perintah diff

Ini saya biaya sedikit untuk memahami apa perbedaan, tapi ini adalah penjelasan sederhana. master di localhost adalah cabang.

Ketika anda menduplikasi sebuah repositori anda mengambil seluruh repositori untuk anda host lokal. Ini berarti bahwa pada saat itu anda memiliki asal/master pointer untuk KEPALA dan master menunjuk ke sama KEPALA.

ketika anda mulai bekerja dan melakukan melakukan anda terlebih dahulu master pointer untuk KEPALA + anda melakukan. Tapi asal/master pointer masih menunjuk ke apa itu ketika anda kloning.

Jadi perbedaan akan:

• Jika anda melakukan git fetch itu hanya akan mengambil semua perubahan dalam repositori (GitHub) dan memindahkan asal/master pointer untuk KEPALA. Sementara itu cabang lokal anda master akan tetap menunjuk ke tempat itu.
• Jika anda melakukan git pull, itu akan dilakukan pada dasarnya mengambil (seperti dijelaskan sebelumnya) dan menggabungkan perubahan yang baru untuk menguasai cabang dan memindahkan pointer ke KEPALA.

Kadang-kadang representasi visual membantu.

Singkat

git fetch mirip dengan menarik tapi doesn't merge. yaitu mengambil remote update (ref dan benda-benda) tapi setempat tetap sama (yaitu asal/master akan diperbarui tapi master tetap sama) .

git pull menarik ke bawah dari jarak jauh dan langsung menyatu.

Lagi

git clone klon repo.

git rebase menyelamatkan barang-barang dari anda saat ini cabang yang isn't di hulu cabang untuk area sementara. Cabang anda sekarang sama seperti sebelum anda memulai perubahan. Jadi, git pull-rebase akan pull down remote perubahan, mundur cabang lokal anda, replay perubahan atas anda saat ini cabang satu per satu sampai anda're up-to-date.

Juga, git branch -a akan menunjukkan anda persis apa yang terjadi dengan semua cabang - lokal dan remote.

Posting blog ini berguna:

Perbedaan antara git pull, git fetch dan git clone (dan git rebase) - Mike Pearce

dan mencakup git pull, git fetch, git clone dan git rebase.

====

UPDATE

Saya pikir saya'd update ini untuk menunjukkan bagaimana anda'd benar-benar menggunakan ini dalam praktek.

1. Update repo lokal dari jarak jauh (tapi don't merge):

git fetch

2. Setelah men-download pembaruan, let's melihat perbedaan:

git diff master asal/master

3. Jika anda're senang dengan update tersebut, kemudian bergabung:

git pull

Catatan:

Langkah 2: Untuk informasi lebih lanjut tentang bedanya antara lokal dan remote, lihat: https://stackoverflow.com/questions/1800783/compare-local-git-branch-with-remote-branch

Pada langkah 3:'s mungkin lebih akurat (misalnya pada cepat berubah repo) untuk melakukan git rebase asal di sini. Lihat @Justin Ohm komentar di lain menjawab.

Lihat juga: http://longair.net/blog/2009/04/16/git-fetch-and-merge/

git-tarik - Fetch dari dan bergabung dengan yang lain repositori atau cabang lokal
SINOPSIS
git pull   ...
DESKRIPSI
Menjalankan git-mengambil dengan parameter yang diberikan, dan panggilan git-merge untuk menggabungkan 
diakses tanggal head(s) ke cabang saat ini. Dengan-rebase, panggilan git-rebase 
bukan git-merge.
Perhatikan bahwa anda dapat menggunakan . (direktori saat ini) sebagai <repositori> untuk menarik 
dari repositori lokal — ini berguna ketika penggabungan cabang-cabang lokal 
ke cabang saat ini.
Juga perhatikan bahwa opsi dimaksudkan untuk git-tarik sendiri dan mendasari git-gabung 
harus diberikan sebelum pilihan dimaksudkan untuk git-fetch.

Anda akan menarik jika anda ingin sejarah digabung, anda'd ambil jika anda hanya 'ingin codez' karena beberapa orang telah menandai beberapa artikel di sini.

Anda dapat mengambil dari repositori jauh, melihat perbedaan dan kemudian tarik atau menggabungkan.

Ini adalah contoh untuk repositori jauh yang disebut asal dan cabang yang disebut guru pelacakan remote branch asal/master:

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

Pendek dan mudah jawabannya adalah bahwa git pull hanya git fetch diikuti oleh git merge.

Hal ini sangat penting untuk dicatat bahwa git pull akan secara otomatis menggabungkan apakah anda suka atau tidak. Ini bisa, tentu saja, menghasilkan gabungan konflik. Let's mengatakan remote asal dan cabang adalah master. Jika anda git diff asal/master sebelum menarik, anda harus memiliki beberapa ide untuk menggabungkan potensi konflik dan bisa mempersiapkan cabang lokal anda sesuai.

Selain itu untuk menarik dan mendorong, beberapa alur kerja melibatkan git rebase, seperti yang satu ini, yang saya mengutip dari artikel terkait:

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

Jika anda menemukan diri anda dalam situasi seperti ini, anda mungkin tergoda untuk git pull --rebase. Kecuali anda benar-benar, benar-benar tahu apa yang anda lakukan, saya akan menyarankan hal itu. Peringatan ini adalah dari manusia halaman git-tarik, versi 2.3.5:

Ini adalah tempat yang berpotensi berbahaya modus operasi. Itu penulisan ulang sejarah, yang tidak pertanda baik ketika anda mempublikasikan bahwa sejarah sudah. Jangan gunakan opsi ini kecuali anda telah membaca git-rebase(1) hati-hati.

OK, berikut ini adalah beberapa informasi tentang git pull dan git fetch, sehingga anda dapat memahami apa sebenarnya perbedaan... dalam beberapa kata-kata sederhana, ambil mendapat data terbaru, tapi bukan perubahan kode dan tidak akan main-main dengan anda saat ini lokal kode cabang, tapi menarik mendapatkan perubahan kode dan menggabungkan cabang lokal anda, baca terus untuk mendapatkan rincian lebih lanjut tentang masing-masing:

git fetch

Itu akan men-download semua ref dan benda dan setiap kantor cabang baru untuk Repositori lokal...

Mengambil cabang-cabang dan/atau kategori (secara kolektif, "ref") dari satu atau lebih repositori lainnya, bersama dengan benda-benda yang diperlukan untuk menyelesaikan mereka sejarah. Remote-pelacakan cabang-cabang yang diperbarui (lihat deskripsi

berikut ini cara untuk mengendalikan perilaku ini).

secara default, setiap tag yang menunjuk ke sejarah yang diambil adalah juga diambil; efek adalah untuk mengambil tags titik itu di cabang-cabang yang anda tertarik. Perilaku default ini dapat diubah dengan menggunakan --kategori atau-tidak-kategori pilihan atau dengan mengkonfigurasi remote.<nama>.tagOpt. Dengan menggunakan refspec yang mengambil kategori secara eksplisit, anda dapat mengambil kategori yang tidak menunjuk ke cabang anda tertarik dalam juga.

git fetch dapat mengambil dari salah satu bernama repositori atau URL, atau dari beberapa repositori sekaligus jika diberikan dan ada remote. entri dalam file konfigurasi. (Lihat git-config1).

Bila tidak ada remote yang ditentukan, secara default asal remote akan digunakan, kecuali ada hulu cabang dikonfigurasi untuk saat ini cabang.

nama-nama wasit yang diambil, bersama-sama dengan nama objek mereka menunjuk, yang ditulis untuk .git/FETCH_HEAD. Informasi ini dapat yang digunakan oleh script atau perintah git, seperti git-tarik.

git pull

Itu akan menerapkan perubahan dari remote ke saat ini cabang di daerah...

Menggabungkan perubahan dari repositori jauh ke cabang saat ini. Dalam mode default, git pull merupakan singkatan dari git fetch diikuti oleh git merge FETCH_HEAD.

Lebih tepatnya, git pull menjalankan git fetch dengan parameter yang diberikan dan panggilan git merge untuk menggabungkan diambil kepala cabang ke saat ini cabang. Dengan-rebase, itu berjalan git rebase bukan git merge.

harus menjadi nama sebuah repositori jauh sebagai diteruskan ke git-fetch[1]. dapat nama yang sewenang-wenang remote ref (misalnya, nama tag) atau bahkan koleksi ref sesuai dengan jauh-cabang pelacakan (misalnya, ref/kepala/*:ref/remote/asal/*), tetapi biasanya itu adalah nama sebuah cabang di repositori.

nilai-nilai Default untuk dan yang dibaca dari "remote" dan "gabung" konfigurasi untuk saat ini cabang yang ditetapkan oleh git-cabang-track.

Saya juga membuat visual di bawah ini untuk menunjukkan kepada anda bagaimana git fetchdangit pull` bekerja bersama-sama...

Interaktif ini representasi grafis sangat membantu dalam understanging git: http://ndpsoftware.com/git-cheatsheet.html

git fetch hanya "popularitas" perubahan dari remote ke local repository. git pull popularitas perubahan dan menggabungkan mereka ke anda saat ini cabang. "Dalam mode default, git pull adalah kependekan dari git fetch diikuti oleh git merge FETCH_HEAD."

Bonus:

Dalam berbicara pull & pengambilan di atas jawaban ini, saya ingin berbagi sebuah trik yang menarik,

git pull --rebase

Ini perintah di atas adalah yang paling berguna perintah di git kehidupan yang menyimpan banyak waktu.

Sebelum mendorong anda baru melakukan ke server, coba perintah ini dan itu akan secara otomatis sync server terbaru perubahan (dengan mengambil + merge) dan akan menempatkan anda melakukan di atas dalam git log. Tidak perlu khawatir tentang manual pull/merge.

Menemukan rincian di: http://gitolite.com/git-pull--rebase

Saya ingin memiliki beberapa representasi visual dari situasi untuk memahami hal-hal ini. Mungkin pengembang lain yang ingin melihatnya juga, jadi di sini's my samping. I'm tidak benar-benar yakin bahwa itu semua adalah benar, jadi silakan komentar jika anda menemukan kesalahan.

                                         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            .                             *

Saya telah berjuang dengan ini juga. Bahkan aku sampai di sini dengan pencarian google dari pertanyaan yang sama persis. Membaca semua jawaban ini akhirnya dicat gambar di kepala saya dan saya memutuskan untuk mencoba untuk mendapatkan ke bawah melihat keadaan 2 repositori dan 1 sandbox dan tindakan yang dilakukan dari waktu ke waktu sambil menonton versi mereka. Jadi di sini adalah apa yang saya datang dengan. Tolong koreksi saya jika saya kacau di mana saja.

Tiga repos dengan mengambil:

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

Tiga repos dengan menarik

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

Ini membantu saya memahami mengapa mengambil cukup penting.

Perbedaan antara GIT Fetch dan GIT Pull dapat menjelaskan dengan skenario berikut: (Menjaga dalam pikiran bahwa gambar berbicara lebih keras daripada kata-kata!, Saya telah memberikan representasi bergambar)

Let's ambil contoh bahwa anda bekerja pada sebuah proyek dengan anggota tim anda. Jadi mereka akan menjadi salah satu Cabang utama dari proyek ini dan semua kontributor harus garpu itu untuk mereka sendiri repositori lokal dan kemudian bekerja pada cabang lokal untuk mengubah/Menambahkan modul kemudian mendorong kembali ke cabang utama.

Jadi, Keadaan awal dari dua Cabang ketika anda bercabang proyek utama pada repositori lokal akan menjadi seperti ini- (A, B dan C adalah modul-Modul yang sudah selesai proyek)

Sekarang, anda telah mulai bekerja pada modul baru (misalkan D) dan ketika anda telah menyelesaikan D modul yang ingin anda push ke cabang utama, Tetapi sementara itu apa yang terjadi adalah bahwa salah satu rekan kerja anda telah mengembangkan Modul baru E, F dan dimodifikasi C.
Jadi sekarang apa yang telah terjadi adalah bahwa repositori lokal kurang belakang asli kemajuan proyek dan dengan demikian mendorong perubahan ke cabang utama dapat menyebabkan konflik dan dapat menyebabkan anda Module D untuk kerusakan.

Untuk menghindari masalah tersebut dan bekerja sejajar dengan yang asli kemajuan proyek mereka ada Dua cara:

1. Git Fetch- Ini akan men-Download semua perubahan yang telah dibuat ke asal/cabang utama proyek yang tidak hadir dalam cabang lokal anda. Dan akan menunggu Git Merge perintah untuk menerapkan perubahan yang telah diambil untuk Repositori anda atau cabang.

Jadi sekarang Anda dapat dengan hati-hati memantau file sebelum penggabungan itu untuk repositori anda. Dan anda juga dapat mengubah D jika diperlukan karena Dimodifikasi C.

2. Git Pull- Ini akan memperbarui cabang lokal anda dengan asal/cabang utama, yaitu benar-benar apa yang dilakukannya adalah kombinasi dari Git Fetch dan Git merge satu setelah yang lain. Tapi hal ini dapat Menyebabkan konflik-Konflik yang terjadi, jadi disarankan untuk menggunakan Git Pull dengan salinan bersih.

Kita hanya mengatakan:

git pull == git fetch + git merge

Jika anda menjalankan git pull, anda tidak perlu untuk menggabungkan data lokal. Jika anda menjalankan git fetch, itu berarti anda harus menjalankan git merge` untuk mendapatkan kode terbaru untuk mesin lokal anda. Jika tidak, mesin lokal kode tidak akan berubah tanpa penggabungan.

Jadi di Git Gui, ketika anda mengambil, anda harus menggabungkan data. Mengambil sendiri won't membuat perubahan kode pada lokal anda. Anda dapat memeriksa bahwa ketika anda memperbarui kode dengan mengambil setelah mengambil dan melihat; kode ini tidak't perubahan. Kemudian anda bergabung... Anda akan melihat kode berubah.

git fetch menarik ke bawah kode dari remote server untuk pelacakan cabang di repositori lokal. Jika anda remote bernama asal (default) maka cabang-cabang ini akan berada dalam asal/, misalnya asal/master, asal/mybranch-123, dll. Ini tidak anda saat ini cabang-cabang, mereka lokal salinan dari cabang-cabang dari server.

git pull tidak git fetch tapi kemudian juga **** menggabungkan kode dari pelacakan cabang ke anda saat ini versi lokal dari cabang itu. Jika anda're tidak siap untuk itu perubahan lagi, hanya git fetch pertama.

git fetch akan mengambil remote cabang sehingga anda dapat git diff atau git merge mereka dengan arus cabang. git pull akan berjalan mengambil remote brach dilacak oleh cabang saat ini dan kemudian menggabungkan hasil. Anda dapat menggunakan git fetch` untuk melihat apakah ada update ke remote branch tanpa perlu menggabungkan mereka dengan cabang lokal anda.