Apa perbedaan antara git pulldan git fetch?

Secara sederhana, git pullapakah git fetchdiikuti oleh a git merge.

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

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

A git pulladalah apa yang akan Anda lakukan untuk memperbarui cabang lokal dengan versi jarak jauh, sekaligus memperbarui cabang pelacakan jarak jauh lainnya.

Dokumentasi git - tarik git :

Dalam mode standarnya, git pulladalah singkatan untuk git fetchdiikuti oleh git merge FETCH_HEAD.

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

• Saat Anda fetch, Git mengumpulkan komit dari cabang target yang tidak ada di cabang Anda saat ini dan menyimpannya di repositori lokal Anda . Namun, itu tidak menggabungkan mereka 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 gunakan merge.

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 bisa 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 ke orang lain, git dapat mentransfernya sebagai satu set perubahan dari titik waktu yang dikenal ke repositori jarak jauh.

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

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

Biasanya git pullmelakukan ini dengan melakukan a git 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 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.

Berikut ini adalah gambar Oliver Steele tentang bagaimana semuanya cocok :

Jika ada minat yang cukup, saya kira saya dapat memperbarui gambar untuk ditambahkan git clonedan git merge...

Satu kasus penggunaan git fetchadalah 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

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

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

Ketika Anda mengkloning repositori Anda mengambil seluruh repositori untuk host lokal Anda. Ini berarti bahwa pada saat itu Anda memiliki pointer asal / master HEADdan master menunjuk ke yang sama HEAD.

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

Jadi perbedaannya adalah:

• Jika Anda melakukannya, git fetchia hanya akan mengambil semua perubahan di repositori jarak jauh ( GitHub ) dan memindahkan pointer asal / master 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.

Terkadang representasi visual membantu.

Secara singkat

git fetchmirip dengan pulltetapi tidak bergabung. yaitu mengambil pembaruan jarak jauh ( refsdan objects) tetapi lokal Anda tetap sama (yaitu origin/masterdiperbarui tetapi mastertetap sama).

git pull menarik turun dari jarak jauh dan langsung menyatu.

Lebih

git clone klon repo.

git rebasemenyimpan barang-barang 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 -rebaseakan menarik perubahan jarak jauh, memundurkan cabang lokal Anda, memutar ulang perubahan Anda dari atas cabang Anda saat ini satu per satu sampai Anda mutakhir.

Juga, git branch -aakan menunjukkan dengan tepat 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 Pearce

dan selimut git pull, git fetch, git clonedan 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 cara membandingkan cabang git lokal dengan cabangnya yang jauh?

Pada langkah 3: Ini mungkin lebih akurat (mis. Pada repo yang cepat berubah) untuk melakukannya di git rebase originsini. Lihat komentar @Justin Ohms di jawaban lain.

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

git-pull - Ambil dan gabungkan dengan repositori lain atau cabang lokal
RINGKASAN

git pull ...
DESKRIPSI

Jalankan git-fetch dengan parameter yang diberikan, dan panggil git-merge untuk menggabungkan 
mengambil kepala ke cabang saat ini. Dengan --rebase, panggilan git-rebase
bukannya git-merge.

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

Perhatikan juga 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 sejarah digabung, Anda akan mengambilnya jika Anda hanya 'ingin kodez' karena beberapa orang telah menandai beberapa artikel di sekitar sini.

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

Ini adalah contoh untuk repositori jarak jauh yang disebut origindan cabang yang disebut masterpelacakan cabang jarak jauh origin/master:

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

Jawaban singkat dan mudah adalah yang git pullhanya git fetchdiikuti oleh git merge.

Sangat penting untuk dicatat bahwa secara otomatisgit pull akan menggabungkan apakah Anda suka atau tidak . Ini tentu saja dapat mengakibatkan penggabungan konflik. Katakanlah remote Anda adalah origindan cabang Anda master. Jika Anda git diff origin/mastersebelum menarik, Anda harus memiliki beberapa ide tentang potensi konflik penggabungan dan dapat mempersiapkan cabang lokal Anda yang sesuai.

Selain menarik dan mendorong, beberapa alur kerja melibatkan git rebase, seperti 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 seperti itu, Anda mungkin tergoda git pull --rebase. Kecuali jika Anda benar-benar tahu apa yang Anda lakukan, saya akan menyarankan untuk tidak melakukannya. Peringatan ini dari manhalaman untuk git-pull, versi 2.3.5:

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

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

git fetch

Ini akan mengunduh semua referensi dan objek serta 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 melengkapi sejarah mereka. Cabang pelacakan jarak jauh diperbarui (lihat uraian di bawah ini untuk mengetahui cara mengendalikan perilaku ini).

Secara default, tag apa pun yang menunjuk ke histori yang sedang diambil juga diambil; efeknya adalah mengambil tag yang mengarah ke cabang yang Anda minati. 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 menunjuk ke 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 upstream yang dikonfigurasi untuk cabang saat ini.

Nama-nama referensi yang diambil, bersama dengan nama-nama objek yang mereka tuju, ditulis ke .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 ...

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

Lebih tepatnya, git pull menjalankan git fetch dengan parameter yang diberikan dan memanggil git merge untuk menggabungkan kepala cabang yang diambil ke cabang saat ini. Dengan --rebase, ia menjalankan git rebase bukannya git merge.

haruslah nama repositori jarak jauh seperti yang dikirimkan ke git-fetch 1 . dapat memberi nama referensi jarak jauh yang sewenang-wenang (misalnya, nama tag) atau bahkan kumpulan referensi dengan cabang pelacakan jarak jauh yang sesuai (misalnya, ref / kepala / : ref / kepala / : ref / remote / asal / ), tetapi biasanya itu adalah nama dari cabang di repositori jarak jauh.

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

Saya juga membuat visual di bawah ini untuk menunjukkan kepada Anda bagaimana git fetchdan git pullbekerja bersama ...

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

git fetchcukup "unduh" perubahan dari jarak jauh ke repositori lokal Anda. git pullmengunduh perubahan dan menggabungkannya ke cabang Anda saat ini. "Dalam mode standarnya, git pulladalah singkatan untuk git fetchdiikuti oleh git merge FETCH_HEAD."

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 atas di log git. Tidak perlu khawatir tentang tarikan / penggabungan manual.

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

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 silakan berkomentar 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 yang diambil dari remote adalah:

• Performa (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 yang asli. Informasi ini dapat diperbarui dengan GIT FETCH).

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 dari waktu ke 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.

Perbedaan antara Ambil GIT dan Tarik GIT 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 membayarnya ke repositori lokal mereka sendiri dan kemudian bekerja di cabang lokal ini untuk memodifikasi / Menambahkan modul kemudian mendorong kembali ke cabang utama.

Jadi, Status Awal dari dua Cabang ketika Anda bercabang proyek utama pada repositori lokal Anda akan seperti ini- ( A, Bdan CModul sudah selesai dari proyek)

Sekarang, Anda sudah mulai bekerja pada modul baru (misalkan D) dan ketika Anda telah menyelesaikan Dmodul Anda ingin mendorongnya ke cabang utama, tetapi sementara itu yang terjadi adalah salah satu rekan tim Anda telah mengembangkan Modul baru E, Fdan dimodifikasi C.
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 Anda Dtidak berfungsi.

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 dilakukan pada 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.

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

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

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 berarti Anda harus menjalankan git mergeuntuk 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.

git fetchmenarik kode dari server jarak jauh ke cabang pelacakan Anda di repositori lokal Anda. Jika remote bernama origin(default) maka cabang tersebut akan berada dalam origin/, misalnya origin/master, origin/mybranch-123, dll Ini bukan cabang Anda saat ini, mereka adalah lokal salinan cabang-cabang dari server.

git pulltidak git fetchtetapi kemudian juga menggabungkan kode dari cabang pelacakan ke versi lokal Anda dari cabang itu. Jika Anda belum siap untuk perubahan itu, git fetchpertama saja .

git fetchakan mengambil cabang jarak jauh sehingga Anda bisa git diffatau git mergemereka dengan cabang saat ini. git pullakan menjalankan pengambilan pada jarak jauh yang dilacak oleh cabang saat ini dan kemudian menggabungkan hasilnya. Anda dapat menggunakan git fetchuntuk melihat apakah ada pembaruan untuk cabang jarak jauh tanpa perlu menggabungkannya dengan cabang lokal Anda.

Git Fetch

Anda mengunduh perubahan ke cabang lokal Anda dari asal hingga mengambil. 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 Merge

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.

Git Pull

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

Satu-satunya perbedaan antara git pulldan git fetchadalah:

git pull menarik dari cabang yang jauh dan menggabungkannya.

git fetch hanya mengambil dari cabang jarak jauh tetapi tidak bergabung

yaitu git pull = git fetch + git merge ...

Secara sederhana, jika Anda akan naik ke pesawat tanpa koneksi internet ... sebelum berangkat Anda bisa melakukannya git fetch origin <master>. Itu akan mengambil semua perubahan ke komputer Anda, tetapi tetap terpisah dari pengembangan / ruang kerja lokal Anda.

Di pesawat, Anda bisa membuat perubahan pada ruang kerja lokal Anda dan kemudian menggabungkannya dengan apa yang telah Anda ambil dan menyelesaikan semua potensi konflik gabungan tanpa koneksi ke Internet. Dan kecuali seseorang telah membuat perubahan baru yang bertentangan pada repositori jarak jauh, maka begitu Anda tiba di tujuan, Anda akan melakukannya git push origin <branch>dan mengambil kopi Anda.

Dari tutorial Atlassian yang mengagumkan ini :

The git fetchperintah download komit, file, dan ref dari repositori jauh ke dalam repositori lokal Anda.

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

Saat mengunduh konten dari repositori jarak jauh, git pulldan git fetchperintah tersedia untuk menyelesaikan tugas. Anda dapat mempertimbangkan git fetchversi 'aman' dari kedua perintah. Ini akan mengunduh konten jarak jauh, tetapi tidak memperbarui kondisi kerja repositori lokal Anda, membiarkan pekerjaan Anda saat ini tetap utuh. git pulladalah alternatif yang lebih agresif, ia akan mengunduh konten jarak jauh untuk cabang lokal aktif dan segera menjalankan git mergeuntuk 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 memengaruhi perkembangan lokal Anda.
• Tidak perlu diperiksa secara eksplisit. Karena itu secara implisit melakukan a git merge.
• Ini pada dasarnya TIDAK aman. Itu agresif.
• Tidak seperti yang git fetchhanya memengaruhi Anda .git/refs/remotes, git pull akan memengaruhi Anda .git/refs/remotes dan .git/refs/heads/

Hmmm ... jadi jika saya tidak memperbarui copy pekerjaan git fetch, lalu di mana saya membuat perubahan? Di mana Git mengambil menyimpan komitmen baru?

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

Di direktori proyek Anda (yaitu, di mana Anda melakukan gitperintah Anda ) lakukan:

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

2. Sekarang lakukan ls -a. Ini akan menunjukkan file dot , yaitu, file dimulai dengan .Anda kemudian akan dapat melihat sebuah 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. headsdan remotes. Gunakan cduntuk memeriksa di dalamnya juga.
6. Apa pun git fetch yang Anda lakukan akan memperbarui item dalam /.git/refs/remotesdirektori. Itu tidak akan memperbarui apa pun di /.git/refs/headsdirektori.
7. Apa git pull pun yang pertama akan dilakukan git fetch, memperbarui item dalam /.git/refs/remotesdirektori, kemudian bergabung dengan lokal Anda dan kemudian mengubah kepala di dalam /.git/refs/headsdirektori.

Jawaban terkait yang sangat baik juga dapat ditemukan di Di mana 'git fetch' menempatkan dirinya? .

Juga, cari "Notasi garis miring " dari pos konvensi penamaan cabang Git . Ini membantu Anda lebih memahami bagaimana Git menempatkan berbagai hal di direktori yang berbeda.

Untuk melihat perbedaan yang sebenarnya

Kerjakan saja:

git fetch origin master
git checkout master

Jika master jarak jauh diperbarui Anda akan mendapatkan pesan seperti ini:

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

Jika Anda tidak fetchdan hanya melakukannya git checkout mastermaka git lokal Anda tidak akan tahu bahwa ada 2 komit yang ditambahkan. Dan itu hanya akan mengatakan:

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

Tapi itu sudah ketinggalan zaman dan salah. Itu karena git akan memberi Anda umpan balik hanya berdasarkan apa yang diketahuinya. Tidak menyadari komitmen baru yang belum ditarik ...

Apakah ada cara untuk melihat perubahan baru yang dibuat di remote saat bekerja di cabang secara lokal?

Beberapa IDE (mis. Xcode) super pintar dan menggunakan hasil dari a git fetchdan dapat memberi anotasi pada baris kode yang telah diubah di cabang jauh dari cabang kerja Anda saat ini. Jika garis itu telah diubah oleh perubahan lokal dan cabang jarak jauh, maka garis itu akan ditandai dengan warna merah. Ini bukan konflik gabungan. Ini potensi konflik penggabungan. Ini adalah headup yang bisa Anda gunakan untuk menyelesaikan konflik penggabungan di masa mendatang sebelum melakukannya git pulldari cabang jarak jauh.

Kiat menyenangkan:

Jika Anda mengambil cabang jarak jauh misal:

git fetch origin feature/123

Maka ini akan masuk ke direktori remote Anda. Itu masih belum tersedia untuk direktori lokal Anda. Namun, ini menyederhanakan checkout Anda ke cabang jauh dengan DWIM (Lakukan apa yang saya maksud):

git checkout feature/123

Anda tidak perlu lagi melakukan:

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

Untuk lebih lanjut baca di sini

Git memungkinkan komitmen yang lebih lama secara kronologis diterapkan setelah komitmen yang lebih baru. Karena itu, tindakan mentransfer komit 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) master@remote >> remote/origin/master@local

2. Mengintegrasikan komitmen baru ke cabang lokal

   (operasi dalam-repo) remote/origin/master@local >> master@local

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 ulang unik untuk repositori lokal.

Dalam gitterminologi, langkah 1 adalah git fetch, langkah 2 adalah git mergeataugit rebase

git pulladalah git fetchdangit merge

Git mendapatkan cabang versi terbaru dari jarak jauh 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 master git log -p master..origin/master git merge origin/master

        Perintah di atas berarti mengunduh versi terbaru dari cabang utama dari asal dari cabang master jarak jauh ke asal. 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 fetchdan git merge. Dalam praktiknya, git fetchmungkin lebih aman karena sebelum penggabungan kita dapat melihat perubahan dan memutuskan apakah akan bergabung.

Apa perbedaan antara git pulldan 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 fetchmembuat salinan lokal repositori jauh Anda terbarui. 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 pulldi sisi lain akan membawa perubahan dalam repositori jarak jauh ke tempat Anda menyimpan kode Anda sendiri. Biasanya, git pullakan melakukan yang git fetchpertama untuk membawa salinan lokal dari repositori jarak jauh, dan kemudian akan menggabungkan perubahan ke dalam repositori kode Anda sendiri dan mungkin juga copy pekerjaan Anda.

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

Berusaha menjadi jelas dan sederhana.

Perintah git pull sebenarnya shortcutuntuk pengambilan git diikuti oleh git merge atau perintah git rebase tergantung pada konfigurasi Anda. Anda dapat mengkonfigurasi repositori Git Anda sehingga git pull adalah pengambilan yang diikuti oleh rebase.

Representasi Grafis sederhana untuk Pemula,

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 master repo jarak jauh Anda adalah cabang Anda

2) git fetch (perlu rebase secara manual):

git fetch origin master

itu akan mengambil perubahan server dari asal. 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.

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

Perintah ini git fetchmembuat 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 pullmembawa perubahan di repositori jarak jauh ke tempat Anda menyimpan kode Anda sendiri. Biasanya, git pulllakukan 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.