it-swarm-id.com

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

Catatan Moderator: Mengingat bahwa pertanyaan ini sudah memiliki enam puluh tujuh jawaban yang diposkan padanya (beberapa di antaranya dihapus), pertimbangkan apakah Andamenyumbangkan sesuatu yang barusebelum memposting yang lain.

Apa perbedaan antara git pull dan git fetch?

10728
pupeno

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

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

Operasi ini tidak pernah mengubah cabang lokal Anda di bawah refs/heads, dan aman dilakukan tanpa mengubah copy pekerjaan Anda. Saya bahkan pernah mendengar ada orang yang menjalankan git fetch secara berkala di pekerjaan cron di latar belakang (walaupun saya tidak akan merekomendasikan melakukan ini).

git pull adalah apa yang akan Anda lakukan untuk memperbarui cabang lokal dengan versi jarak jauhnya, sambil juga memperbarui cabang pelacakan jarak jauh Anda yang lain.

Dokumentasi git: git pull

8962
Greg Hewgill
  • Ketika Anda menggunakan pull, Git mencoba melakukan pekerjaan Anda secara otomatis untuk Anda. Ini peka konteks , jadi Git akan menggabungkan komit yang ditarik ke cabang tempat Anda bekerja saat ini. pull secara otomatis menggabungkan komit tanpa membiarkan Anda meninjaunya . Jika Anda tidak mengelola cabang dengan cermat, Anda mungkin sering mengalami konflik.

  • Ketika Anda fetch, Git mengumpulkan komit dari cabang target yang tidak ada di cabang Anda saat ini dan menyimpannya di repositori lokal Anda . Namun, tidak menggabungkannya dengan cabang Anda saat ini . Ini sangat berguna jika Anda perlu memperbarui repositori Anda, tetapi sedang mengerjakan sesuatu yang mungkin rusak jika Anda memperbarui file Anda. Untuk mengintegrasikan komit ke cabang master Anda, Anda menggunakan merge.

1969
Mouna Cheikhna

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

Subversion dirancang dan dibangun dengan model klien/server. Ada satu repositori yang merupakan server, dan beberapa klien dapat mengambil kode dari server, mengerjakannya, lalu mengkomitnya kembali ke server. Asumsinya adalah bahwa klien selalu dapat menghubungi server ketika perlu melakukan operasi.

Git dirancang untuk mendukung model yang lebih terdistribusi tanpa perlu repositori pusat (meskipun Anda tentu bisa menggunakannya jika mau). Juga git dirancang agar klien dan "server" tidak perlu online pada saat bersamaan. Git dirancang agar orang-orang di tautan yang tidak bisa diandalkan dapat bertukar kode melalui email, bahkan. Dimungkinkan untuk bekerja sepenuhnya terputus dan membakar CD untuk bertukar kode melalui git.

Untuk mendukung model ini, git mengelola repositori lokal dengan kode Anda dan juga repositori lokal tambahan yang mencerminkan keadaan repositori jarak jauh. Dengan menyimpan salinan repositori jarak jauh secara lokal, git dapat mengetahui perubahan yang diperlukan bahkan ketika repositori jarak jauh tidak dapat dijangkau. Kemudian ketika Anda perlu mengirim perubahan kepada orang lain, git dapat mentransfernya sebagai satu set perubahan dari titik waktu yang dikenal ke repositori jarak jauh.

  • git fetchadalah perintah yang mengatakan "perbarui salinan lokal dari repositori jarak jauh saya." 

  • git pullmengatakan "bawa perubahan di repositori jauh ke tempat saya menyimpan kode saya sendiri."

Biasanyagit pullmelakukan ini dengan melakukangit fetchuntuk membuat salinan lokal repositori jarak jauh up to date, dan kemudian menggabungkan perubahan ke dalam repositori kode Anda sendiri dan mungkin juga copy pekerjaan Anda.

Cara mengambilnya adalah dengan mengingat bahwa sering ada setidaknya tiga salinan dari sebuah proyek di workstation Anda. Satu salinan adalah repositori Anda sendiri dengan riwayat komit Anda sendiri. Salinan kedua adalah copy pekerjaan Anda di mana Anda mengedit dan membangun. Salinan ketiga adalah salinan "cached" lokal Anda dari repositori jarak jauh.

1104
MikeD

Berikut adalah gambar Oliver Steele tentang bagaimana semuanya cocok :

enter image description here

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

744
Contango

Satu contoh penggunaan git fetch adalah bahwa yang berikut ini akan memberi tahu Anda perubahan di cabang jarak jauh sejak penarikan terakhir Anda ... sehingga Anda dapat memeriksa sebelum melakukan penarikan yang sebenarnya, yang dapat mengubah file di cabang Anda saat ini dan copy pekerjaan.

git fetch
git diff ...Origin
446
mepster

Saya perlu sedikit biaya untuk memahami apa bedanya, tetapi ini adalah penjelasan sederhana. master di localhost Anda adalah cabang.

Ketika Anda mengkloning repositori, Anda mengambil seluruh repositori untuk Host lokal. Ini berarti bahwa pada saat itu Anda memiliki Origin/master pointer ke HEAD dan master menunjuk ke HEAD yang sama.

ketika Anda mulai bekerja dan melakukan komit Anda memajukan pointer master ke HEAD + komitmen Anda. Tapi Origin/master pointer masih menunjuk ke apa itu ketika Anda dikloning.

Jadi perbedaannya adalah:

  • Jika Anda melakukan git fetch itu hanya akan mengambil semua perubahan di repositori jarak jauh ( GitHub ) dan memindahkan Origin/master pointer ke HEAD. Sementara itu, master cabang lokal Anda akan terus menunjuk ke tempatnya.
  • Jika Anda melakukan git pull, itu pada dasarnya akan mengambil (seperti yang dijelaskan sebelumnya) dan menggabungkan setiap perubahan baru ke cabang master Anda dan memindahkan pointer ke HEAD.
351
Gerardo

Terkadang representasi visual membantu.

 enter image description here

195
thedarkpassenger

Secara singkat

git fetch mirip dengan pull tetapi tidak bergabung. yaitu mengambil pembaruan jarak jauh (refs dan objects) tetapi lokal Anda tetap sama (mis. Origin/master diperbarui tetapi master tetap sama).

git pull menarik turun dari jarak jauh dan langsung menyatu.

Lebih Banyak

git clone mengkloning repo.

git rebase menyimpan hal-hal dari cabang Anda saat ini yang tidak ada di cabang hulu ke area sementara. Cabang Anda sekarang sama dengan sebelum Anda memulai perubahan Anda. Jadi, git pull -rebase akan menarik perubahan jarak jauh, memundurkan cabang lokal Anda, memutar ulang perubahan Anda dari atas cabang saat ini satu per satu hingga Anda mendapatkan informasi terbaru.

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

Posting blog ini bermanfaat:

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.

====

MEMPERBARUI

Saya pikir saya akan memperbarui ini untuk menunjukkan bagaimana Anda benar-benar menggunakannya dalam praktik. 

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

    git fetch 
    
  2. Setelah mengunduh pembaruan, mari kita lihat perbedaannya:

    git diff master Origin/master 
    
  3. Jika Anda puas dengan pembaruan itu, gabungkan:

    git pull
    

Catatan:

Pada langkah 2: Untuk informasi lebih lanjut tentang perbedaan antara local dan remote, lihat: Bagaimana membandingkan cabang git lokal dengan cabangnya yang jauh?

Pada langkah 3: Mungkin lebih akurat (mis. Pada repo yang berubah cepat) untuk melakukan git rebase Origin di sini. Lihat @Justin Ohms komentar di jawaban lain.

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

189
Snowcrash
 git-pull - Ambil dan gabungkan dengan repositori lain atau cabang lokal 
 SYNOPSIS 

 git pull .... 
 DESKRIPSI 

 Menjalankan git-fetch dengan parameter yang diberikan, dan memanggil git-merge untuk menggabungkan 
 kepala yang diambil ke cabang saat ini. Dengan --rebase, panggil git-rebase 
 Alih-alih git-merge .

 Perhatikan bahwa Anda dapat menggunakan. (direktori saat ini) sebagai <repositori> untuk menarik .__ dari repositori lokal - ini berguna ketika menggabungkan cabang lokal .__ ke dalam cabang saat ini .

 Juga perhatikan bahwa opsi yang dimaksudkan untuk git-pull sendiri dan git-merge yang mendasarinya 
 harus diberikan sebelum opsi yang dimaksudkan untuk git-fetch .

Anda akan menarik jika Anda ingin riwayat digabung, Anda akan mengambilnya jika Anda hanya 'ingin kodez' karena beberapa orang telah menandai beberapa artikel di sekitar sini.

164
Vinko Vrsalovic

Anda dapat mengambil dari repositori jarak jauh, melihat perbedaannya lalu menarik atau menggabungkannya.

Ini adalah contoh untuk repositori jarak jauh bernama Origin dan cabang bernama master yang melacak cabang jarak jauh Origin/master:

git checkout master                                                  
git fetch                                        
git diff Origin/master
git rebase Origin master
151
Antonio Bardazzi

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

Sangat penting untuk dicatat bahwa git pull akan secara otomatis menggabungkan apakah Anda suka atau tidak. Ini tentu saja dapat mengakibatkan penggabungan konflik. Katakanlah remote Anda Origin dan cabang Anda master. Jika Anda git diff Origin/master sebelum menarik, Anda harus memiliki beberapa ide tentang potensi konflik penggabungan dan dapat menyiapkan cabang lokal Anda sesuai dengan itu. 

Selain menarik dan mendorong, beberapa alur kerja melibatkan git rebase, seperti ini, yang saya kutip dari artikel yang ditautkan:

git pull Origin master
git checkout foo-branch
git rebase master
git Push Origin foo-branch

Jika Anda menemukan diri Anda dalam situasi seperti itu, Anda mungkin tergoda untuk git pull --rebase. Kecuali jika Anda benar-benar tahu apa yang Anda lakukan, saya akan menyarankan untuk tidak melakukannya. Peringatan ini berasal dari halaman man untuk git-pull, versi 2.3.5:

Ini adalah mode operasi yang berpotensi berbahaya. Itu menulis ulang sejarah, yang bukan pertanda baik ketika Anda menerbitkan sejarah itu sudah. Jangan gunakan opsi ini kecuali Anda telah membaca git-rebase (1) hati-hati.

145
jfmercer

OK, berikut adalah beberapa informasi tentang git pull dan git fetch, sehingga Anda dapat memahami perbedaan yang sebenarnya ... dalam beberapa kata sederhana, fetch mendapatkan data terbaru, tetapi kode tidak berubah dan tidak akan untuk mengacaukan dengan kode cabang lokal Anda saat ini, tetapi pull dapatkan perubahan kode dan menggabungkannya dengan cabang lokal Anda, baca terus untuk mendapatkan detail lebih lanjut tentang masing-masing:

git fetch

Ini akan mengunduh semua referensi dan objek dan cabang baru ke Gudang lokal Anda ...

Ambil cabang dan/atau tag (secara kolektif, "ref") dari satu atau lebih repositori lainnya, bersama dengan objek yang diperlukan untuk menyelesaikan .__ mereka. sejarah Cabang pelacakan jarak jauh diperbarui (lihat deskripsi Di bawah ini untuk cara-cara mengendalikan perilaku ini).

Secara default, tag apa pun yang menunjukkan histori yang diambil adalah juga diambil; efeknya adalah untuk mengambil tag yang mengarah ke cabang yang Anda tertarik. Perilaku default ini dapat diubah dengan menggunakan opsi --tags atau --no-tag atau dengan mengkonfigurasi remote..tagOpt. Dengan menggunakan refspec yang mengambil tag secara eksplisit, Anda dapat mengambil tag yang tidak menunjukkan cabang yang Anda minati juga.

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

Ketika tidak ada remote yang ditentukan, secara default remote asal akan digunakan, kecuali ada cabang hulu yang dikonfigurasi untuk arus cabang.

Nama-nama referensi yang diambil, bersama dengan nama-nama objek mereka menunjuk, ditulis ke .git/FETCH_HEAD. Informasi ini mungkin digunakan oleh skrip atau perintah git lainnya, seperti git-pull.


git pull

Ini akan menerapkan perubahan dari remote ke cabang saat ini di ...

Menggabungkan perubahan dari repositori jarak jauh ke cabang saat ini . Dalam mode standarnya, git pull adalah singkatan untuk git fetch diikuti oleh git menggabungkan FETCH_HEAD.

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

harus menjadi nama repositori jarak jauh sebagaimana diteruskan ke git-fetch 1 . dapat memberi nama referensi jarak jauh yang sewenang-wenang (misalnya, nama tag) atau bahkan koleksi referensi yang sesuai cabang pelacakan jarak jauh (mis., ref/kepala/: ref/remote/Asal /), .__ tetapi biasanya itu 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 visual di bawah ini untuk menunjukkan kepada Anda bagaimana git fetch dan git pull bekerja bersama ...

 git pull and git fetch

126
Alireza

enter image description here

Representasi grafis interaktif ini sangat membantu dalam memahami git: http://ndpsoftware.com/git-cheatsheet.html

git fetch cukup "unduh" perubahan dari jarak jauh ke repositori lokal Anda. git pull mengunduh perubahan dan menggabungkannya ke cabang Anda saat ini. "Dalam mode standarnya, git pull adalah singkatan untuk git fetch diikuti oleh git merge FETCH_HEAD."

121
th3sly

Bonus:

Dalam berbicara tentang menarik & mengambil 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 menghemat banyak waktu.

Sebelum mendorong komit baru Anda ke server, coba perintah ini dan itu akan secara otomatis menyinkronkan perubahan server terbaru (dengan mengambil + gabungan) dan akan menempatkan komit Anda di bagian atas dalam log git. Tidak perlu khawatir tentang tarikan/penggabungan manual.

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

119

Saya suka memiliki representasi visual dari situasi untuk memahami hal-hal ini. Mungkin pengembang lain juga ingin melihatnya, jadi inilah tambahan saya. Saya tidak sepenuhnya yakin bahwa 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'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.

Beberapa keuntungan utama karena memiliki mirror jarak jauh yang diambil adalah:

  • Kinerja (gulir semua komit dan pesan tanpa mencoba memerasnya melalui jaringan)
  • Umpan balik tentang keadaan repo lokal Anda (misalnya, saya menggunakan SourceTree dari Atlassian, yang akan memberi saya bohlam yang menunjukkan jika saya melakukan di depan atau di belakang dibandingkan dengan Asal. Informasi ini dapat diperbarui dengan GIT FETCH ).
109
Justus Romijn

Saya telah berjuang dengan ini juga. Sebenarnya saya sampai di sini dengan pencarian google dari pertanyaan yang persis sama. Membaca semua jawaban ini akhirnya melukiskan gambar di kepala saya dan saya memutuskan untuk mencoba memahami keadaan 2 repositori dan 1 kotak pasir dan tindakan yang dilakukan seiring waktu sambil menonton versi mereka. Jadi inilah yang saya pikirkan. Harap perbaiki saya jika saya mengacau di mana saja.

Tiga repo 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 repo dengan tarikan

---------------------     -----------------------     -----------------------
- 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 cukup penting.

99
pn1 dude

Perbedaan antara GIT Fetch dan GIT Pull dapat dijelaskan dengan skenario berikut: (Perlu diingat bahwa gambar berbicara lebih keras daripada kata-kata !, saya telah memberikan representasi gambar)

Mari kita ambil contoh bahwa Anda sedang mengerjakan proyek dengan anggota tim Anda. Jadi mereka akan menjadi salah satu Cabang utama dari proyek dan semua kontributor harus garpu untuk repositori lokal mereka sendiri dan kemudian bekerja pada cabang lokal ini untuk memodifikasi/Menambahkan modul kemudian Dorong kembali ke cabang utama.

Jadi, Status Awal dari dua Cabang ketika Anda bercabang proyek utama pada repositori lokal Anda akan seperti ini- (A, B dan C adalah Modul yang sudah selesai dari proyek)

 enter image description here

Sekarang, Anda sudah mulai bekerja pada modul baru (misalkan D) dan ketika Anda telah menyelesaikan modul D Anda ingin Dorong ke cabang utama, tetapi sementara itu yang terjadi adalah salah satu rekan tim Anda telah mengembangkan Modul baru E, F dan C yang dimodifikasi.
Jadi sekarang apa yang terjadi adalah bahwa repositori lokal Anda kurang di belakang kemajuan asli proyek dan dengan demikian mendorong perubahan Anda ke cabang utama dapat menyebabkan konflik dan dapat menyebabkan Modul D Anda tidak berfungsi.

 enter image description here

Untuk menghindari masalah-masalah seperti itu dan untuk bekerja secara paralel dengan kemajuan asli proyek mereka ada dua cara:

1. Git Fetch- Ini akan Mengunduh semua perubahan yang telah dibuat untuk proyek Asal/cabang utama yang tidak ada di cabang lokal Anda. Dan akan menunggu perintah Git Merge untuk menerapkan perubahan yang telah diambil ke Repositori atau cabang Anda.

 enter image description here

Jadi sekarang Anda dapat dengan hati-hati memonitor file sebelum menggabungkannya ke repositori Anda. Dan Anda juga dapat memodifikasi D jika diperlukan karena Modifikasi C.

 enter image description here

2. Tarik Git- Ini akan memperbarui cabang lokal Anda dengan Asal/cabang utama yaitu apa yang dilakukannya adalah kombinasi dari Git Fetch dan Git menggabungkan satu demi satu .Tetapi ini dapat menyebabkan Konflik untuk terjadi, jadi disarankan untuk menggunakan Git Pull dengan salinan yang bersih.

 enter image description here

89
Aman Tiwari

Kami hanya mengatakan:

git pull == git fetch + git merge

Jika Anda menjalankan git pull, Anda tidak perlu menggabungkan data ke lokal. Jika Anda menjalankan git fetch, itu artinya Anda harus menjalankan git merge untuk mendapatkan kode terbaru ke mesin lokal Anda. Kalau tidak, kode mesin lokal tidak akan berubah tanpa penggabungan. 

Jadi di Git Gui, ketika Anda mengambil, Anda harus menggabungkan data. Ambil sendiri tidak akan membuat perubahan kode di lokal Anda. Anda dapat memeriksa bahwa ketika Anda memperbarui kode dengan mengambil Sekali mengambil dan melihat; kode itu tidak akan berubah. Kemudian Anda menggabungkan ... Anda akan melihat kode yang diubah.

82
Selvamani

git fetch menarik kode dari server jauh ke cabang pelacakan Anda di repositori lokal Anda. Jika remote Anda bernama Origin (default) maka cabang-cabang ini akan berada dalam Origin/, misalnya Origin/master, Origin/mybranch-123, dll. Ini bukan cabang Anda saat ini, itu adalah salinan local cabang-cabang dari server.

git pull melakukan git fetch tetapi kemudian juga menggabungkan kode dari cabang pelacakan ke versi lokal Anda saat itu dari cabang itu. Jika Anda belum siap untuk perubahan itu, cukup git fetch terlebih dahulu.

80
Michael Durrant

git fetch akan mengambil cabang jarak jauh sehingga Anda dapat git diff atau git merge dengan cabang saat ini. git pull akan menjalankan fetch pada remote brach yang dilacak oleh cabang saat ini dan kemudian menggabungkan hasilnya. Anda dapat menggunakan git fetch untuk melihat apakah ada pembaruan pada cabang jarak jauh tanpa perlu menggabungkannya dengan cabang lokal Anda.

75
ntanase

Ambil Git

Anda mengunduh perubahan ke cabang lokal Anda dari Asal melalui pengambilan. Fetch meminta repo jarak jauh untuk semua komitmen yang dibuat orang lain tetapi Anda tidak memilikinya di repo lokal Anda. Ambil unduhan komit ini dan tambahkan ke repositori lokal.

Git Gabung

Anda dapat menerapkan perubahan yang diunduh melalui pengambilan menggunakan perintah gabungan. Gabung akan mengambil komit yang diambil dari pengambilan dan mencoba menambahkannya ke cabang lokal Anda. Penggabungan akan menyimpan histori komit dari perubahan lokal Anda sehingga saat Anda berbagi cabang dengan Push, Git akan tahu bagaimana orang lain dapat menggabungkan perubahan Anda.

Tarik Git

Ambil dan gabungkan jalankan bersama cukup sering sehingga perintah yang menggabungkan keduanya, tarik, telah dibuat. Tarik melakukan pengambilan dan kemudian bergabung untuk menambahkan komit yang diunduh ke cabang lokal Anda.

71
Pinkesh Sharma

Satu-satunya perbedaan antara git pull dan git fetch adalah:

git pull menarik dari cabang jarak jauh dan menggabungkannya.

git fetch hanya mengambil dari cabang jarak jauh tetapi tidak bergabung

mis. git pull = git mengambil + git menggabungkan ...

50

Git memungkinkan komit yang lama secara kronologis diterapkan setelah komit yang lebih baru . Karena itu, tindakan mentransfer komit di antara repositori dibagi menjadi dua langkah:

  1. Menyalin komitmen baru dari cabang jarak jauh untuk menyalin cabang jarak jauh ini di dalam repo lokal. 

    (operasi repo ke repo) [email protected] >> remote/Origin/[email protected]

  2. Mengintegrasikan komitmen baru ke cabang lokal

    (operasi repo dalam) remote/Origin/[email protected] >> [email protected]

Ada dua cara melakukan langkah 2. Anda bisa:

  1. Garpu cabang lokal setelah leluhur bersama terakhir dan tambahkan komit baru paralel ke komit yang unik untuk repositori lokal, diselesaikan dengan menggabungkan komit, menutup fork. 
  2. Masukkan komit baru setelah leluhur bersama terakhir dan aplikasikan kembali unik ke repositori lokal.

Dalam git terminologi, langkah 1 adalah git fetch, langkah 2 adalah git merge atau git rebase

git pull adalah git fetch dan git merge

44
Pawel Furmaniak

Apa perbedaan antara git pull dan git fetch?

Untuk memahami hal ini, pertama-tama Anda perlu memahami bahwa git lokal Anda tidak hanya menyimpan repositori lokal Anda, tetapi juga memelihara salinan lokal repositori jarak jauh.

git fetch memperbarui salinan repositori jarak jauh lokal Anda. Misalnya, jika repositori jarak jauh Anda adalah GitHub - Anda mungkin ingin mengambil perubahan apa pun yang dibuat dalam repositori jarak jauh ke salinan lokal Anda dari repositori jauh itu. Ini akan memungkinkan Anda untuk melakukan operasi seperti membandingkan atau menggabungkan.

git pull di sisi lain akan membawa perubahan dalam repositori jarak jauh ke tempat Anda menyimpan kode Anda sendiri. Biasanya, git pull akan melakukan git fetch terlebih dahulu untuk membawa salinan lokal repositori jarak jauh, dan kemudian akan menggabungkan perubahan ke dalam repositori kode Anda sendiri dan mungkin juga copy pekerjaan Anda. 

36
Donal

Git mendapatkan cabang versi terbaru dari remote ke lokal menggunakan dua perintah: 

  1. git fetch: Git akan mendapatkan versi terbaru dari jarak jauh ke lokal, tetapi tidak secara otomatis bergabung . git fetch Origin mastergit log -p master..Origin/mastergit merge Origin/master

     Perintah di atas berarti mengunduh versi terbaru dari cabang utama dari Origin dari remote ke cabang master Origin. Dan kemudian membandingkan cabang master lokal dan cabang master Asal. Akhirnya, gabung. 

  2. git pull: Git akan mendapatkan versi terbaru dari jarak jauh dan bergabung ke lokal.

     git pull Origin master

     Perintah di atas setara dengan git fetch dan git merge. Dalam praktiknya, git fetch mungkin lebih aman karena sebelum penggabungan kita dapat melihat perubahan dan memutuskan apakah akan menggabungkan.

35
Marcus Thornton

git pull == (git fetch + git merge) 

git fetch tidak berubah ke cabang lokal.

Jika Anda sudah memiliki repositori lokal dengan pengaturan jarak jauh untuk proyek yang diinginkan, Anda dapat mengambil semua cabang dan tag untuk jarak jauh yang ada menggunakan git fetch. ... Ambil tidak membuat perubahan apa pun pada cabang lokal, jadi Anda harus menggabungkan cabang jarak jauh dengan cabang lokal berpasangan untuk memasukkan perubahan yang baru diambil. dari github

33
Iggy

Sebenarnya Git menyimpan salinan kode Anda sendiri dan Repositori jarak jauh.

Perintah git fetch membuat salinan lokal Anda mutakhir dengan mendapatkan data dari repositori jarak jauh. Alasan kami membutuhkan ini adalah karena orang lain mungkin telah membuat beberapa perubahan pada kode dan Anda ingin menjaga diri Anda diperbarui. 

Perintah git pull membawa perubahan dalam repositori jarak jauh ke tempat Anda menyimpan kode Anda sendiri. Biasanya, git pull melakukan ini dengan melakukan ‘git fetch’ terlebih dahulu untuk membawa salinan lokal repositori jarak jauh, dan kemudian menggabungkan perubahan ke dalam repositori kode Anda sendiri dan mungkin juga copy pekerjaan Anda.

32
Pokemon

Berusaha menjadi jelas dan sederhana.

Perintah git pull sebenarnya shortcut untuk git fetch diikuti oleh git merge atau perintah git rebase tergantung pada konfigurasi Anda. Anda dapat mengonfigurasi repositori Git Anda sehingga git pull adalah pengambilan yang diikuti oleh rebase.

31
montells

Representasi Grafis sederhana untuk Pemula,

 enter image description here

sini,

git pull  

akan mengambil kode dari repositori dan rebase dengan lokal Anda ... di git pull ada kemungkinan komit baru dibuat.

tapi di, 

git fetch 

akan mengambil kode dari repositori dan kita perlu rebase secara manual dengan menggunakan git rebase

misalnya: saya akan mengambil dari master server dan rebase di master lokal saya.

1) git pull (rebase akan dilakukan secara otomatis):

git pull Origin master

di sini Asal adalah repo jarak jauh Anda master adalah cabang Anda

2) git fetch (perlu rebase secara manual):

git fetch Origin master

itu akan mengambil perubahan server dari Origin. dan itu akan berada di lokal Anda sampai Anda rebase sendiri. kita perlu memperbaiki konflik secara manual dengan memeriksa kode.

git rebase Origin/master

ini akan mengubah kode menjadi lokal. sebelum itu pastikan Anda berada di cabang kanan.

30
git pull = git fetch + git merge 
29
Saqib R.

From Pro Git § 2.5 Dasar-Dasar Git - Bekerja dengan Remote: Mengambil dan Menarik dari Remote Anda :

Penting untuk dicatat bahwa perintah fetch menarik data ke repositori lokal Anda - tidak secara otomatis menggabungkannya dengan pekerjaan Anda atau memodifikasi apa yang Anda sedang mengerjakan. Anda harus menggabungkannya secara manual ke dalam pekerjaan Anda ketika kamu siap.

Jika Anda memiliki cabang yang diatur untuk melacak cabang jarak jauh, Anda dapat menggunakan perintah git pull untuk secara otomatis mengambil dan kemudian menggabungkan remote cabang ke cabang Anda saat ini. Ini mungkin lebih mudah atau lebih alur kerja yang nyaman untuk Anda; dan secara default, perintah git clone secara otomatis mengatur cabang master lokal Anda untuk melacak remote cabang master di server tempat Anda dikloning (dengan anggapan remote memiliki cabang master). Menjalankan git pull umumnya mengambil data dari server tempat Anda melakukan kloning dan secara otomatis mencoba untuk menggabungkannya ke dalam kode yang sedang Anda kerjakan.

28
Zhenxiao Hao

git pull 

Ia melakukan dua fungsi menggunakan perintah tunggal.

Itu mengambil semua perubahan yang dibuat ke cabang jauh dan kemudian menggabungkan perubahan itu ke cabang lokal Anda. Anda juga dapat mengubah perilaku tarik dengan melewatkan --rebase. Perbedaan antara penggabungan dan rebase dapat dibaca di sini

git fetch

Git fetch hanya melakukan setengah dari pekerjaan git pull. Itu hanya membawa perubahan jarak jauh ke repo lokal Anda tetapi tidak menerapkannya ke cabang Anda. Anda harus secara eksplisit menerapkan perubahan itu. Hal ini dapat dilakukan sebagai berikut:

git fetch
git rebase Origin/master
22
Animesh Sharma

Orang harus mengingat sifat git. Anda memiliki remote dan cabang lokal Anda (tidak harus sama). Dibandingkan dengan sistem kontrol sumber lain ini bisa sedikit membingungkan. 

Biasanya ketika Anda checkout remote, salinan lokal dibuat yang melacak remote. 

git fetch akan bekerja dengan cabang jarak jauh dan memperbarui informasi Anda. 

Sebenarnya demikian halnya jika SWE lain bekerja di satu cabang yang sama, dan jarang dalam skenario proyek kecil - satu cabang - satu.

Pekerjaan Anda di cabang lokal masih utuh. Untuk membawa perubahan ke cabang lokal Anda, Anda harus menggabungkan/rebase perubahan dari cabang jarak jauh.

git pull melakukan kedua langkah ini dengan tepat (mis. --rebase untuk rebase bukan gabungan)

Jika histori lokal Anda dan histori jarak jauh mengalami konflik, Anda akan dipaksa untuk melakukan penggabungan selama Push git untuk mempublikasikan perubahan Anda.

Jadi itu benar-benar tergantung pada sifat lingkungan kerja Anda dan mengalami apa yang harus digunakan.

22
g24l

Dari lembar contekan git

git fetch <remote> // Download all changes from <remote>, but don't integrate into HEAD
git pull <remote> <branch> // Download changes and directly merge/integrate into HEAD
20
Nan Xiao

Dari apa yang saya mengerti, 

Git pull - Menarik ke bawah dari jarak jauh yang ditentukan (Ditentukan oleh pengguna) dan langsung akan menggabungkannya ke cabang tempat kita berada sekarang. Ini pada dasarnya adalah campuran dari perintah Ambil dan Gabungkan.

Git Fetch - Ini sama dengan Tarik, tetapi tidak akan melakukan penggabungan. Jadi, Anda dapat memonitor file dengan hati-hati sebelum menggabungkannya. 

Url ini harus membantu untuk pemahaman lebih lanjut: Perbedaan antara tarikan git, git fetch dan git clone (dan git rebase).

17
Pragyaditya Das

Secara singkat dan sederhana:

git fetch: Lihat apakah ada barang baru.

git pull: Ambil barang baru dan letakkan di atas barang-barang Anda. 

8
miva2

Saya percaya sebagian besar jawaban menjawab perbedaan dengan cukup baik. Saya akan menekankan kapan harus menggunakan yang sebaliknya.

 Enter image description here

Ambil dapat bermanfaat saat Anda perlu mendapatkan pembaruan dari pengembang lain, namun ingin melanjutkan pekerjaan Anda tanpa terhalang. Orang yang sering ingin offline dan bekerja menggunakan fetch untuk mendapatkan pembaruan terbaru sampai dia online. Kemudian ketika dia merasa nyaman dengan perubahannya, gabungkan yang dari cabang ke dalam ruang kerjanya.

Sedangkan orang yang bekerja online dan sangat yakin akan perubahan mereka dan ingin mendapatkan kode terbaru dan merge langsung menggunakan pull. Saya jarang menggunakan fetch karena untuk memeriksa pembaruan terbaru saya memeriksanya melalui situs web GitHub dan saya selalu bekerja offline. Seperti yang saya sebutkan, Anda mungkin menggunakan skenario di atas.

5
ishandutta2007

Git Fetch

Membantu Anda mengetahui tentang pembaruan terkini dari git repository. Katakanlah Anda bekerja dalam sebuah tim menggunakan GitFlow, di mana tim bekerja di beberapa branches (fitur). Dengan git fetch --allcommand Anda dapat diketahui tentang semua branches baru dalam repository.

Biasanya git fetch digunakan dengan git reset. Misalnya Anda ingin mengembalikan semua perubahan lokal Anda ke status repositori saat ini.

git fetch --all // get known about latest updates
git reset --hard Origin/[branch] // revert to current branch state

Git pull

Perintah ini memperbarui branch Anda dengan status repositorybranch saat ini. Mari kita lanjutkan dengan GitFlow. Beberapa fitur branches adalah merged ke develop cabang dan ketika Anda ingin mengembangkan fitur baru untuk proyek Anda harus pergi ke mengembangkan branch dan melakukan git pull untuk mendapatkan keadaan saat ini developbranch

Dokumentasi untuk GitFlow https://Gist.github.com/peterdeweese/4251497

3
Andrei Todorut

Git fetch menyinkronkan katalog repositori jarak jauh ke lokal Anda. Itu tidak akan menggabungkan perubahan file/kode dari jarak jauh ke cabang lokal Anda.

Git pull mengunduh perubahan yang terkait dengan cabang lokal Anda saat ini dan kemudian menggabungkannya.

1
Arnel Lenteria

Dari Attlassian tutorial yang mengagumkan ini: 

Perintah git fetch unduhan melakukan, file, dan referensi dari repositori jarak jauh ke repo lokal Anda. 

Mengambil adalah apa yang Anda lakukan ketika Anda ingin melihat apa yang sudah dikerjakan semua orang lain. Ini mirip dengan pembaruan svn karena memungkinkan Anda melihat bagaimana sejarah pusat telah berkembang, tetapi itu tidak memaksa Anda untuk benar-benar menggabungkan perubahan ke dalam repositori Anda. Git isolate mengambil konten sebagai dari konten lokal yang ada, itu benar-benar tidak berpengaruh pada pekerjaan pengembangan lokal Anda. Konten yang diambil harus diperiksa secara eksplisit menggunakan perintah git checkout. Ini membuat mengambil cara yang aman untuk meninjau komit sebelum mengintegrasikannya dengan repositori lokal Anda.

Saat mengunduh konten dari repo jarak jauh, perintah git pull dan git fetch tersedia untuk menyelesaikan tugas. Anda dapat menganggap git fetch versi 'aman' dari kedua perintah. Ini akan mengunduh konten jarak jauh tetapi tidak memperbarui keadaan repo lokal Anda, membiarkan pekerjaan Anda saat ini tetap utuh. git pull adalah alternatif yang lebih agresif, ia akan mengunduh konten jarak jauh untuk cabang lokal yang aktif dan segera menjalankan git merge untuk membuat komit gabungan untuk konten jarak jauh yang baru. Jika Anda memiliki perubahan dalam proses yang tertunda ini akan menyebabkan konflik dan memulai aliran resolusi konflik gabungan.


Dengan git pull:

  • Anda tidak mendapatkan isolasi. 
  • Ini berdampak pada pengembangan lokal Anda.
  • Tidak perlu diperiksa secara eksplisit. Karena secara implisit melakukan git merge.
  • Ini pada dasarnya TIDAK aman. Itu agresif.
  • Tidak seperti git fetch yang hanya memengaruhi .git/refs/remotes Anda, tarikan git akan memengaruhi .git/refs/remotesdan.git/refs/heads/ Anda juga.

Hmmm ... jadi jika saya tidak memperbarui copy pekerjaan dengan git fetch, lalu di mana saya membuat perubahan? Di mana git mengambil toko commit baru?

Pertanyaan yang bagus Ini menempatkannya di suatu tempat yang terisolasi dari copy pekerjaan Anda. Tapi lagi dimana? Ayo cari tahu.

Dalam direktori proyek Anda (yaitu di mana Anda melakukan perintah git Anda) lakukan: 

  1. ls. Ini akan menampilkan file & direktori. Tidak ada yang keren, saya tahu.

  2. Sekarang lakukan ls -a. Ini akan menampilkan dot file yaitu file yang dimulai dengan . Anda kemudian dapat melihat direktori bernama: .git

  3. Lakukan cd .git. Ini jelas akan mengubah direktori Anda. 
  4. Sekarang tiba bagian menyenangkan; lakukan ls. Anda akan melihat daftar direktori. Kami sedang mencari refs. Lakukan cd refs.
  5. Sangat menarik untuk melihat apa yang ada di dalam semua direktori, tetapi mari kita fokus pada dua di antaranya. heads dan remotes. Gunakan cd untuk memeriksa di dalamnya juga. 
  6. git fetch APA PUN yang Anda lakukan akan memperbarui item dalam direktori /.git/refs/remotes. Itu tidak akan memperbarui apa pun di direktori /.git/refs/heads.
  7. git pull APA PUN pertama akan melakukan git fetch, memperbarui item dalam direktori /.git/refs/remotes, kemudian bergabung dengan lokal Anda dan kemudian mengubah kepala di dalam direktori /.git/refs/heads

Jawaban terkait yang sangat baik juga dapat ditemukan Di mana tempat 'git fetch' sendiri?

Juga cari "Notasi Slash" dari konvensi penamaan cabang Git post.

1
Honey