Apa perbedaan antara 'git pull' dan 'git fetch'?

Catatan moderator. Mengingat enam puluh tujuh balasan telah dikirim ke pertanyaan ini (beberapa di antaranya telah dihapus), pertimbangkan apakah Anda menambahkan sesuatu yang baru sebelum mengirim yang lain.

Apa perbedaan antara git pull dan git fetch ?

10.500
15 нояб. atur pupeno 15 nov. 2008-11-15 12:51 '08 pada 12:51 2008-11-15 12:51
@ 46 jawaban
  • 1
  • 2

Dalam istilah yang paling sederhana, git pull mengeksekusi git fetch diikuti oleh git merge .

Anda dapat melakukan git fetch kapan saja untuk memperbarui cabang pelacakan jarak jauh di refs/remotes/<remote>/ .

Operasi ini tidak pernah mengubah cabang lokal Anda sendiri di refs/heads dan aman tanpa mengubah copy pekerjaan. Saya bahkan mendengar bahwa orang secara berkala menjalankan git fetch pekerjaan cron di latar belakang (walaupun saya tidak akan merekomendasikannya).

git pull adalah apa yang akan Anda lakukan untuk memperbarui cabang lokal dengan versi jarak jauh Anda, serta memperbarui cabang pelacakan jarak jauh lainnya.

Dokumentasi Git: Tarik git

8755
15 нояб. Balas diberikan oleh Greg Hewgill 15 Nov 2008-11-15 12:52 '08 pada 12:52 2008-11-15 12:52
  • Ketika Anda menggunakan pull , Git mencoba melakukan pekerjaan Anda secara otomatis untuk Anda. Ini peka terhadap konteks , jadi Git akan menggabungkan setiap push yang dilakukan ke cabang yang sedang Anda kerjakan. pull secara otomatis menggabungkan komit tanpa membiarkan Anda melihatnya terlebih dahulu . Jika Anda tidak pandai mengelola cabang Anda, Anda mungkin sering menghadapi konflik.

  • Saat Anda fetch , Git mengumpulkan komit dari cabang target yang tidak ada di cabang Anda saat ini, tetapi menyimpannya di repositori lokal Anda . Namun, itu tidak menggabungkannya dengan cabang Anda saat ini . Ini sangat berguna jika Anda perlu memperbarui repositori Anda secara terus-menerus, tetapi kerjakan apa yang mungkin rusak jika Anda memperbarui file Anda. Untuk mengintegrasikan komit ke cabang utama, Anda menggunakan merge .

border=0
1919
18 авг. balasan yang diberikan oleh Mouna Cheikhna 18 Agustus. 2011-08-18 11:53 '11 pada 11:53 2011-08-18 11:53

Penting untuk membandingkan filosofi desain git dengan filosofi alat manajemen sumber yang lebih tradisional, seperti SVN.

Subversi dirancang dan dibangun menggunakan model klien / server. Ada satu repositori, yang merupakan server, dan beberapa klien dapat mengekstrak kode dari server, bekerja dengannya, dan kemudian mentransfernya kembali ke server. Diasumsikan bahwa klien selalu dapat menghubungi server ketika dia perlu melakukan operasi.

Git dirancang untuk mendukung model yang lebih terdistribusi tanpa perlu repositori pusat (walaupun Anda tentu dapat menggunakannya jika Anda mau). Juga, git dirancang sedemikian rupa sehingga klien dan "server" tidak boleh online pada saat yang sama. Git dirancang agar orang-orang di tautan yang tidak dapat diandalkan bahkan dapat bertukar kode melalui email. Anda dapat sepenuhnya menonaktifkan pekerjaan dan membakar CD untuk bertukar kode melalui git.

Untuk mendukung model ini, git mengelola repositori lokal dengan kode Anda, serta repositori lokal tambahan yang mencerminkan keadaan repositori jarak jauh. Dengan menyimpan salinan repositori jarak jauh secara lokal, git dapat menentukan perubahan yang diperlukan, bahkan jika repositori jarak jauh tidak tersedia. Kemudian, ketika Anda perlu mengirim perubahan ke orang lain, git dapat mentransfernya sebagai satu set perubahan dari titik waktu yang diketahui ke repositori jarak jauh.

  • git fetch adalah perintah yang mengatakan: "Bawa salinan lokal saya dari repositori jarak jauh."

  • git pull mengatakan: "Bawa perubahan ke repositori jarak jauh tempat saya menyimpan kode saya sendiri."

Biasanya, git pull melakukan ini dengan menjalankan git fetch untuk memperbarui salinan lokal repositori jarak jauh, dan kemudian menggabungkan perubahan ke dalam repositori kode Anda sendiri dan mungkin juga copy pekerjaan Anda.

Hapus ini untuk diingat bahwa sering ada setidaknya tiga salinan proyek di workstation Anda. Satu salinan adalah repositori Anda sendiri dengan riwayat komitnya sendiri. Salinan kedua adalah copy pekerjaan Anda, tempat Anda mengedit dan membuat. Salinan ketiga adalah salinan "cache" lokal Anda dari repositori jarak jauh.

1066
31 марта '13 в 21:43 2013-03-31 21:43 jawabannya diberikan oleh MikeD 31 Maret '13 pada 21:43 2013-03-31 21:43
711
09 июня '15 в 16:30 2015-06-09 16:30 jawabannya diberikan Contango 09 Juni '15 pukul 4.30 sore 2015-06-09 16:30

Salah satu penggunaan git fetch adalah bahwa pesan berikut ini akan memberi tahu Anda tentang perubahan di cabang jarak jauh sejak tarikan terakhir ... sehingga Anda dapat memeriksa sebelum melakukan tarikan yang sebenarnya, yang dapat mengubah file di cabang Anda saat ini dan menjalankan salinan .

 git fetch git diff ...origin 
437
07 мая '10 в 22:23 2010-05-07 22:23 jawabannya diberikan kepada mepster 07 Mei '10 pukul 10:23 2010-05-07 22:23

Saya harus mengerti sedikit apa perbedaannya, tetapi ini adalah penjelasan sederhana. master di localhost Anda adalah cabang.

Ketika Anda mengkloning repositori, Anda mendapatkan seluruh repositori untuk host lokal. Ini berarti bahwa saat ini Anda memiliki pointer asal / master pada HEAD dan master menunjuk ke HEAD sama.

ketika Anda mulai bekerja dan Anda melakukan ini, Anda mentransfer master pointer ke HEAD + fiksasi Anda. Tapi pointer asal / master masih menunjukkan apa itu ketika Anda dikloning.

Jadi, perbedaannya adalah:

  • Jika Anda menjalankan git fetch , ia hanya akan mengekstrak semua perubahan di repositori jarak jauh ( GitHub ) dan memindahkan pointer start / master ke HEAD . Sementara itu, panduan cabang lokal Anda akan terus menunjukkan di mana ia berada.
  • Jika Anda melakukan git pull , itu pada dasarnya akan mengekstrak (seperti yang dijelaskan sebelumnya) dan menggabungkan setiap perubahan baru ke cabang utama dan memindahkan pointer ke HEAD .
347
11 мая '12 в 21:37 2012-05-11 21:37 jawabannya diberikan Gerardo 11 Mei '12 pada 21:37 2012-05-11 21:37

Terkadang presentasi visual membantu.

2019

25 янв. jawabannya diberikan oleh penumpang utama 25 Januari. 2016-01-25 20:28 '16 pada 8:28 malam 2016-01-25 20:28

sebentar

git fetch mirip dengan pull tetapi tidak bergabung. yaitu itu mengekstrak pembaruan jarak jauh ( refs dan objects ), tetapi lokal Anda tetap tidak berubah (mis., origin/master diperbarui, tetapi master tetap sama).

git pull dijatuhkan dari konsol dan >

Lebih banyak

git clone clone repos.

git rebase menyimpan material dari cabang Anda saat ini yang tidak ada di cabang naik ke area sementara. Utas Anda sekarang sama dengan sebelum Anda memulai perubahan Anda. Jadi, git pull -rebase mengeluarkan perubahan yang dihapus, memundurkan cabang lokal Anda, u>

Selain itu, git branch -a akan menunjukkan kepada Anda apa yang terjadi dengan semua cabang Anda - lokal dan jarak jauh.

Posting blog ini bermanfaat:

Perbedaan antara tarikan git, git ambil dan git klon (dan git rebase) - Mike Pierce

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

====

PEMBARUAN

Saya pikir saya memperbarui itu untuk menunjukkan bagaimana Anda benar-benar menggunakannya dalam praktek.

  1. Perbarui repo lokal Anda dari perangkat jarak jauh (tapi jangan satukan):

     git fetch 
  2. Setelah mengunduh pembaruan, lihat perbedaannya:

     git diff master origin/master 
  3. Jika Anda puas dengan pembaruan ini, gabungkan:

     git pull 

Catatan:

Pada >perangkat lokal dan jarak jauh, lihat Bagian: Bagaimana membandingkan cabang git lokal dengan cabang jarak jauh?

Pada >git rebase origin . Lihat @Justin Ohms Comment dalam jawaban lain.

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

170
13 апр. Jawab Snowcrash 13 Apr 2013-04-13 20:31 '13 jam 8:31 malam 2013-04-13 20:31
 git-pull - ambil dari dan gabungkan dengan repositori lain atau cabang lokal SINOPSIS git tarik ... DESKRIPSI Jalankan git-fetch  mengambil kepala ke cabang saat ini.  Dengan --rebase, panggilan git-rebase  bukannya git-merge. Perhatikan bahwa Anda dapat menggunakan.  (direktori saat ini) sebagai tempat penyimpanan <repositori>  dari repositori lokal - ini berguna saat menggabungkan cabang lokal  ke cabang saat ini. Git-pull  untuk git-fetch.

Anda akan menarik, jika Anda ingin menggabungkan cerita, Anda akan mendapatkan jika Anda hanya "menginginkan kode," karena beberapa dari mereka menaruh beberapa artikel di sini.

161
15 нояб. Balas diberikan oleh Vinko Vrsalovic 15 Nov 2008-11-15 12:52 '08 pada 12:52 2008-11-15 12:52

Anda dapat mengekstrak dari repositori jarak jauh, melihat perbedaannya, lalu menarik atau menggabungkan.

Ini adalah contoh repositori jarak jauh bernama origin dan cabang bernama master , yang melacak cabang origin/master jarak jauh:

 git checkout master git fetch git diff origin/master git rebase origin master 
147
21 марта '11 в 14:07 2011-03-21 14:07 jawabannya diberikan oleh Antonio Bardazzi 21 Maret '11 pada 14:07 2011-03-21 14:07

Jawaban singkat dan sederhana adalah bahwa git pull hanyalah git fetch diikuti oleh git merge .

Sangat penting untuk dicatat bahwa git pull secara otomatis bergabung, apakah Anda suka atau tidak . Ini, tentu saja, dapat menyebabkan penggabungan konflik. Katakanlah konsol Anda adalah origin dan cabang Anda adalah master . Jika Anda git diff origin/master sebelum menarik, Anda harus menyadari potensi konflik penggabungan dan dapat menyiapkan cabang lokal Anda sesuai.

Selain menarik dan mengklik, beberapa alur kerja menyertakan git rebase , misalnya, yang ini, yang saya kutip 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 ini, Anda mungkin tergoda oleh git pull --rebase . Jika Anda benar-benar tidak tahu apa yang Anda lakukan, saya akan menyarankan untuk melakukannya. Ini adalah peringatan dari halaman man untuk git-pull , versi 2.3.5 :

Ini adalah mode operasi yang berpotensi berbahaya. Dia menulis u>

139
15 мая '11 в 23:53 2011-05-15 23:53 jawabannya diberikan oleh jfmercer 15 Mei '11 di 23:53 2011-05-15 23:53

2019

117
06 февр. jawabannya diberikan th3sly 06 Feb. 2015-02-06 14:48 '15 pada 14:48 2015-02-06 14:48

Nah , berikut adalah beberapa informasi tentang git pull dan git fetch , sehingga Anda dapat memahami perbedaan sebenarnya ... dalam beberapa kata sederhana, fetch mendapatkan data terbaru, tetapi tidak mengubah kode dan tidak akan menghubungi kode cabang lokal Anda saat ini, tetapi mengeluarkan kode dengan perubahan dan gabungkan ke cabang lokal Anda, baca terus untuk mendapatkan informasi lebih rinci tentang masing-masing:

git fetch

Ini akan mengunduh semua tautan dan objek serta cabang baru ke repositori lokal Anda ...

Pilih cabang dan / atau tag (bersama-sama, "referensi") dari satu atau lebih repositori lainnya, bersama dengan objek yang diperlukan untuk menyelesaikan cerita mereka. Cabang pelacakan jarak jauh yang diperbarui (lihat Deskripsi di bawah ini untuk mengetahui cara mengendalikan perilaku ini).

Secara default, tag apa pun yang mengarah ke cerita yang diekstraksi juga diambil; efeknya adalah mengekstrak tag yang mengarah ke cabang yang Anda minati. Perilaku default ini dapat diubah menggunakan opsi --tags atau --no-tag atau dengan mengatur remote..tagOpt. Menggunakan refspec, yang secara eksplisit mengekstrak tag, Anda dapat mengekstrak tag yang tidak mengarah ke cabang yang Anda minati.

git fetch dapat diambil dari repositori atau URL bernama tunggal, atau dari beberapa repositori sekaligus, jika diberikan, dan ada konsol. tulis ke file konfigurasi. (Lihat Git-config 1 ).

Jika tidak ada perangkat jarak jauh yang ditentukan, sumber awal default digunakan, kecuali cabang hulu dikonfigurasi untuk cabang saat ini.

Nama-nama tautan yang dipilih, bersama dengan nama-nama objek yang mereka tuju, dicatat di.git / FETCH_HEAD. Informasi ini dapat digunakan oleh skrip atau perintah git lainnya, seperti git-pull.


git pull

Ini akan menerapkan perubahan dari jarak jauh ke cabang saat ini di ...

Termasuk perubahan dari repositori jauh ke cabang saat ini. Dalam mode default, git pull adalah kependekan dari git fetch, diikuti oleh git merge FETCH_HEAD.

Lebih khusus, git pull menjalankan git fetch dengan parameter yang diberikan dan memanggil git merge untuk menggabungkan header cabang yang diterima ke cabang saat ini. Menggunakan --rebase, ia menjalankan git rebase bukannya git merge.

seharusnya nama repositori jarak jauh yang dilewatkan ke git-fetch 1 . dapat memanggil referensi jarak jauh yang sewenang-wenang (misalnya, nama tag) atau bahkan kumpulan tautan dengan cabang pelacakan jarak jauh yang sesuai (misalnya, ref / kepala /: ref / remote / asal /), tetapi biasanya ini adalah nama cabang di repositori jarak jauh.

Nilai default untuk dan dibaca dari konfigurasi "jarak jauh" dan "gabungan" untuk cabang saat ini, sebagaimana ditetapkan oleh git-branch --track.


Saya juga membuat gambar visual di bawah ini untuk menunjukkan kepada Anda bagaimana git fetch dan git pull bekerja bersama ...

2019

Bonus:

Berbicara tentang peregangan dan penggalian dalam jawaban di atas, saya ingin berbagi trik yang menarik,

git pull --rebase

Perintah di atas adalah perintah yang paling berguna dalam hidup git saya, yang telah menghemat banyak waktu.

Sebelum mendorong komit baru ke server, coba perintah ini dan itu akan secara otomatis menyinkronkan perubahan server terbaru (menggunakan fetch + merge) dan menempatkan pesan Anda di awal di git log. Tidak perlu khawatir tentang menarik / menyatukan tangan.

Temukan informasi di: http://gitolite.com/git-pull--rebase

113
23 дек. Jawabannya diberikan oleh Sazzad Hissain Khan pada 23 Desember. 2015-12-23 18:31 '15 pada 18:31 2015-12-23 18:31

Saya suka memiliki semacam representasi visual dari situasi untuk memahami hal-hal ini. Mungkin pengembang lain juga ingin melihat ini, jadi inilah tambahan saya. Saya tidak yakin semuanya benar, jadi tolong beri 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 . . . FETCH *------------------>* Your local cache of the remote is updated with the origin (or multiple external sources, that is git 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. 

Beberapa manfaat utama memiliki gambar cermin konsol adalah:

  • Kinerja (menggulir semua komit dan pesan tanpa mencoba mengompresnya melalui jaringan)
  • Umpan balik tentang status repo lokal Anda (misalnya, saya menggunakan Atlassian SourceTree, yang akan memberi saya bola lampu yang menunjukkan apakah saya akan maju atau mundur dibandingkan dengan sumbernya. Perbarui dengan GIT FETCH).
107
20 февр. Jawabannya diberikan oleh Justus Romijn pada 20 Feb. 2014-02-20 00:18 '14 pada 0:18 2014-02-20 00:18

Saya juga berjuang dengan ini. Bahkan, saya sampai di sini dengan pencarian Google untuk pertanyaan yang persis sama. Setelah membaca semua jawaban ini, saya akhirnya menggambar di kepala saya, dan saya memutuskan untuk mencoba berurusan dengan keadaan 2 repositori dan 1 kotak pasir, dan tindakan dilakukan dengan waktu, menonton versi mereka. Jadi, itulah yang saya pikirkan. Harap perbaiki saya jika saya mengacau.

Tiga repositori dengan sampel:

 --------------------- ----------------------- ----------------------- - 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 repositori dengan beban

 --------------------- ----------------------- ----------------------- - 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 pengambilan sampel sangat penting.

95
17 июля '12 в 19:43 2012-07-17 19:43 jawabannya diberikan pn1 dude 17 Juli '12 pada jam 19:43 2012-07-17 19:43

Perbedaan antara GIT Fetch dan GIT Pull dapat dijelaskan dengan skenario berikut: (Mengingat bahwa gambar berbicara lebih keras daripada kata-kata! Saya memberikan representasi grafis)

Mari kita asumsikan bahwa Anda sedang mengerjakan proyek dengan anggota tim Anda. Dengan demikian, mereka akan menjadi salah satu divisi utama dari proyek, dan semua peserta harus bercabang di repositori lokal mereka sendiri, dan kemudian bekerja di cabang lokal ini untuk mengubah / menambah modul, dan kemudian kembali ke cabang utama.

Jadi, keadaan awal dari dua cabang, ketika Anda bercabang proyek utama di repositori lokal Anda, akan seperti ini- ( A , B dan C adalah modul yang sudah selesai dalam proyek)

2019

ответ дан Aman Tiwari 07 февр. '17 в 17:15 2017-02-07 17:15