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


11919

Apa perbedaan antara git pulldan git fetch?


364
Saya menemukan artikel yang ditulis dengan baik tentang git fetch dan git pull itu layak dibaca: longair.net/blog/2009/04/16/git-fetch-and-merge
Marcos Oliveira

51
Pendekatan alternatif kami telah menjadi git fetch; git reset --hard origin/masterbagian dari alur kerja kami. Itu membuat perubahan lokal, membuat Anda tetap up to date dengan master TAPI memastikan Anda tidak hanya melakukan perubahan baru di atas perubahan saat ini dan membuat berantakan. Kami telah menggunakannya untuk sementara waktu dan pada dasarnya terasa jauh lebih aman dalam praktik. Pastikan untuk menambahkan / melakukan / simpanan pekerjaan apa pun yang sedang berjalan terlebih dahulu!
Michael Durrant

26
Pastikan Anda tahu cara menggunakan git simpanan dengan benar. Jika Anda bertanya tentang 'tarik' dan 'ambil' maka mungkin 'simpanan' juga perlu dijelaskan ...
Henry Heleine

36
Banyak orang yang datang dari Mercurial tetap menggunakan "git pull", berpikir itu setara dengan "hg pull". Yang mana tidak. Setara Git dengan "hg pull" adalah "git fetch".
Serge Shultz

8
perintah git fetch mengambil kode yang diperbarui dengan cabang dan juga akan mendapatkan cabang yang baru ditambahkan di lokal Anda, perintah git pull hanya mengambil kode yang diperbarui dari cabang saat ini saja
Kartik Patel

Jawaban:


9920

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.


326
"A" git pull "adalah apa yang akan Anda lakukan untuk memperbarui repositori Anda" <- bukankah pembaruan repositori sudah dilakukan dengan mengambil? bukankah itu berarti membuat cabang lokal Anda mutakhir dengan cabang yang jauh? Ke penggabungan: Ini menggabungkan cabang-cabang terpencil dengan salinan lokal dari cabang-cabang itu, atau apa tepatnya menggabungkan di sini?
Albert

194
@Albert: Ya, ini kata-kata yang aneh. git pullakan selalu bergabung ke cabang saat ini . Jadi Anda pilih cabang yang Anda ingin menarik dari , dan menariknya ke dalam cabang saat ini. The dari cabang dapat lokal atau remote; bahkan bisa berupa cabang jarak jauh yang bukan terdaftar git remote(artinya Anda meneruskan URL di git pullbaris perintah).
intuited

129
@ espertus: Tidak. Mendorong tidak pernah secara otomatis melakukan penggabungan. Pengguna diharapkan untuk menarik, menyelesaikan konflik penggabungan secara lokal, lalu mendorong kembali ke remote.
Greg Hewgill

33
Jika saya di /home/alice/dan lakukan git fetch /home/bob, parameter apa yang harus saya sampaikan ke yang berikutnya git merge?
ripper234

106
Catatan untuk orang yang belajar Git: pullsebenarnya tidak dapat ditiru oleh nilai fetchtambah a merge. Saya baru saja mengambil perubahan di mana hanya penunjuk cabang jarak jauh berubah, dan mergemenolak untuk melakukan apa pun. pull, di sisi lain, maju cepat cabang pelacakan saya.
Roman Starkov

2173
  • 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.


34
Setuju, komentar yang bagus. Itulah sebabnya saya benci git pull. Kapan masuk akal untuk membiarkan alat revisi membuat kode diedit untuk Anda? Dan bukankah itu yang dilakukan penggabungan dua file? Bagaimana jika kedua suntingan secara fisik dipisahkan dalam file, tetapi secara LOGIS berselisih?
Lee Dixon

126
@elexhobby singkatnya, git fetchhanya memperbarui .git/direktori Anda (AKA: repositori lokal) dan tidak ada di luar .git/(AKA: working tree). Itu tidak mengubah cabang lokal Anda, dan itu tidak menyentuh masterbaik. Menyentuh remotes/origin/mastermeskipun (lihat git branch -avv). Jika Anda memiliki lebih banyak remote, coba git remote update. Ini adalah git fetchuntuk semua remote di satu perintah.
Tino

24
@Tino milikmu benar-benar poin terpenting. Orang mungkin tidak tahu bahwa cabang "remote" sebenarnya disimpan sebagai sekelompok hash .git/refs/remotes/origin/.
Chris

13
Ketika Anda mengambil, Git mengumpulkan komit dari cabang target yang tidak ada di cabang Anda saat ini dan menyimpannya di repositori lokal Anda - bagaimana cara melihat apa yang dibawa dari jarak jauh dan bagaimana cara menggabungkannya ke cabang lokal saya?
ア レ ッ ク ス

13
@Tino Yang saya masih tidak mengerti adalah ... apa gunanya? Mengapa menggunakan fetch jika hanya memperbarui .git? Apa manfaat yang dimaksudkan dan apa yang harus saya lakukan setelah itu?
BadHorsie

1210

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.


75
Secara teknis, repositori lokal dan remote benar-benar satu dan sama. Di Git, repositori adalah DAG dari commit yang menunjuk ke orang tua mereka. Cabang, secara teknis, tidak lebih dari nama komit yang bermakna. Satu-satunya perbedaan antara cabang lokal dan jarak jauh adalah bahwa cabang jarak jauh diawali dengan remoteName/ Git dari bawah ke atas adalah bacaan yang sangat bagus. Setelah Anda memahami bagaimana Git bekerja - dan ini sangat sederhana , sungguh - semuanya masuk akal.
Emil Lundberg

13
Terima kasih banyak atas penjelasannya. Saya tidak benar-benar mengerti sampai sekarang bahwa Git dirancang sehingga Anda tidak perlu memiliki repositori pusat. Semua orang selalu mengatakan "DVCS" ketika menggambarkan Git, tetapi sebagai programmer yang relatif baru, itu tidak ada artinya bagi saya. Saya belum pernah melihat CVCS, dan saya juga tidak pernah bekerja dengan repositori cental jarak jauh ketika berkolaborasi dengan orang lain (yaitu Github), jadi sampai sekarang saya belum mengerti apa yang membuat Git istimewa.
Brian Peterson

7
Jadi, berdasarkan ini, mengapa bukan ide yang baik untuk mengambil pekerjaan cron? Selalu menyimpan salinan remote yang Anda kerjakan di komputer lokal Anda sepertinya ide yang bagus. Bahkan, saya merasa ingin menulis skrip yang memeriksa untuk melihat apakah saya telah memperbarui remote saya dalam 24 jam terakhir dan menghubungkannya dengan udev hook untuk koneksi internet.
Brian Peterson

24
Salah satu alasan mengapa itu bukan ide yang baik untuk memiliki pekerjaan cron: sering ketika mengerjakan baik tiket baru, atau tentang pembaruan ke cabang, saya suka melihat perubahan yang diambil. Jika perubahan tidak muncul saat pengambilan, saya akan lebih percaya diri dalam bertanya kepada sesama programmer saya 'hei apakah Anda mendorong?'. Saya juga merasakan berapa banyak 'churn' di repositori sejak saya terakhir mengambil. Ini juga membantu memberi saya pengertian tentang jumlah dan kecepatan perubahan yang saat ini dibuat untuk repositori ini.
Michael Durrant

5
@Nabheet Thing adalah itu, Git berorientasi pada konten. Ini menyimpan data hanya sekali, dan menunjuk ke sana beberapa kali. Itu sebabnya di Git, bahkan banyak komit di atas dokumen asli tidak banyak mempengaruhi ukuran repo, karena sebagian besar objek adalah sama.
cst1992

890

Berikut ini adalah gambar Oliver Steele tentang bagaimana semuanya cocok :

masukkan deskripsi gambar di sini

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


156
Gambar yang diperbarui dengan git clonedan git mergeakan sangat membantu!
MEMark

20
Ya, harap tambahkan git merge- ini harus dengan jelas menunjukkan bahwa mergememanggil secara terpisah TIDAK sama dengan menelepon pullkarena pullhanya menggabungkan dari jarak jauh dan mengabaikan komit lokal Anda di cabang lokal Anda yang melacak cabang jarak jauh yang ditarik.
JustAMartin

12
Sebuah gambar bernilai ribuan kata! Apakah gambar yang diperbarui dengan aliran data klon dan gabungan siap di suatu tempat? Adakah aliran data lain selain yang sudah ada dalam diagram?
shikhanshu

10
@Contango tambahkan clone dan gabung. Akan sangat membantu bagi pemula seperti saya.
sewa

11
Ada dua diagram yang menunjukkan clone dan gabung dalam jawaban lain (di bawah) oleh th3sly dan thedarkpassenger.
intotecho

488

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


9
mengapa tidak git diff ..origin?
Erik Kaplun

3
git diff origin dan git diff ..origin tampaknya berfungsi tetapi tidak aneh ... barang
Marc

19
@Compustretch Tidak seharusnya ada spasi. git diff ...originsetara dengan git diff $(git-merge-base HEAD origin) origin(lihat git diff [--options] <commit>...<commit> [--] [<path>…]bagian kernel.org/pub/software/scm/git/docs/git-diff.html#_description ), yang berbeda dari git diff origin; git diff ...originsecara konseptual perubahan yang dibuat originsejak cabang saat ini bercabang origin, sementara git diff originjuga termasuk kebalikan dari perubahan yang dibuat di cabang saat ini sejak cabang itu bercabang origin.
Max Nanasy

2
tidak ada .. perintah yang bekerja untuk saya (pada Windows), tetapi git diff origin/masterberfungsi, seperti yang disebutkan di bawah ini
Brian Burns

sama di sini menggunakan git 2.0.0 di OSX. Tidak satu pun dari perintah ini yang berfungsi. Apakah mereka sudah ditinggalkan?
K.-Michael Aye

373

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.

14
asal / master adalah cabang lokal yang merupakan SALINAN master pada asal. Ketika Anda mengambil, Anda memperbarui lokal: / asal / master. Setelah Anda benar-benar mengerti bahwa semua yang ada di git adalah cabang, ini sangat masuk akal dan merupakan cara yang sangat kuat untuk mempertahankan perubahan yang berbeda, membuat cabang lokal cepat, bergabung dan rebase, dan umumnya mendapatkan banyak nilai dari percabangan murah model.
cam8001

3
Masih membingungkan. Saya pikir git fetchbenar-benar mengunduh perubahan pada repo jarak jauh ke repo lokal Anda, tetapi BUKAN melakukan itu - yaitu, mereka masih perlu ditambahkan / berkomitmen untuk repo lokal Anda.
krb686

3
ambil hanya tarikan dari jarak jauh / asal (github) ke asal Anda. Tapi itu tidak menggabungkannya dengan file kerja Anda yang sebenarnya. jika Anda melakukan tarik, itu akan mengambil dan menggabungkan ke file Anda saat ini
Gerardo

223

Terkadang representasi visual membantu.

masukkan deskripsi gambar di sini


18
Saya pikir gambar harus menunjukkan bahwa itu mempengaruhi repo lokal juga. Artinya, Git pull adalah kombinasi yang memengaruhi repo lokal dan copy pekerjaan. Saat ini sepertinya itu hanya mempengaruhi copy pekerjaan.
nonopolaritas

10
@太極者無極而生Setuju - gambar ini cukup menyesatkan, karena itu membuatnya tampak seperti git pullsedang melompat-lompat pengambilan, yang tentu saja tidak akurat.
forresthopkinsa

9
apa perbedaan antara 'Repositori Lokal' dan 'Copy Pekerjaan'? Bukankah keduanya lokal di komputer?
theITvideos

1
Apa gunanya git fetch? bagaimana cara melihat perbedaan apa yang ada di repositori lokal dan copy pekerjaan?
Vikash

2
@theITvideos Tidak, tidak. Repositori lokal adalah tempat kode Anda (dari repositori yang berfungsi) saat Anda komit. (Ini pergi ke repo jarak jauh ketika Anda menekan).
Vikash

219

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/


1
Kedengarannya bagi saya seperti jika seseorang hanya ingin kode lokal untuk mencerminkan "tip", mereka harus menggunakan git clone. Saya memberi tip dalam tanda kutip, karena saya berasumsi itu akan berarti apa pun masternya dan apa yang seseorang "Unduh sebagai zip" dari github.com
Chris K

3
bagaimana jika Anda tidak puas dengan perubahan setelah Anda mengambilnya? apa yang harus dilakukan selanjutnya
Kugutsumen

Paragraf Anda tentang rebase adalah apa yang saya cari. Seluruh gagasan tentang memberi nol pada segalanya, memperbarui dari jarak jauh, kemudian memutar ulang perubahan Anda di atas komitmen sebelumnya yang terjadi saat Anda sedang bekerja. Penjelasan sempurna dengan asumsi itu benar. ;)
coblr

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


5
Sangat menarik, tetapi saya tidak dapat benar-benar melihat kasus penggunaan di mana Anda ingin "hanya kode". Dan apa yang terjadi dengan kode Anda saat Anda mengambil? Apakah terhapus? Apa yang terjadi dengan perubahan jarak jauh? Bagaimana cara masuk ke repo Anda tanpa menghapus kode Anda jika Anda tidak bergabung?
e-satis

11
@ e-satis: Cabang jarak jauh juga disimpan secara lokal di mesin Anda. Jadi ketika Anda melakukannya, git fetchia mengambil perubahan dari repositori dan memperbarui cabang jarak jauh lokal Anda. Itu tidak mempengaruhi cabang lokal Anda yang melacak cabang jauh lokal, jadi tidak mempengaruhi copy pekerjaan Anda. Sekarang, ketika Anda melakukan mergeitu akan menggabungkan perubahan yang diambil dengan cabang lokal Anda.
jeffreyveon

Kasus penggunaan sederhana untuk perintah pengambilan: melakukan operasi yang memakan waktu yang melibatkan komitmen orang lain baru-baru ini, seperti penggabungan atau tinjauan kode, hanya mengakses repositori lokal terkini Anda tanpa persyaratan konektivitas jaringan, karena sebelumnya Anda menggunakan unduhan untuk mengunduh semua yang Anda butuhkan dengan cepat (mis. saat Anda mengunjungi beberapa pengembang lain dan terhubung ke jaringan repositori lain). Perintah tarikan akan mengunduh komit yang sama, tetapi penggabungan yang dilakukannya dapat tidak diinginkan.
Lorenzo Gatti

163

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

35
Anda mungkin ingin melewatkan tarikan dan lakukan "git rebase origin" sebagai langkah terakhir karena Anda sudah mengambil perubahan. Alasannya adalah bahwa seseorang dapat mendorong perubahan dalam waktu sejak Anda melakukan pengambilan dan ini tidak akan terjadi pada saat Anda melakukan tinjauan berbeda.
Justin Ohms

158

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.


2
@JustinOhms Jika git pull --rebasebukan hal yang benar dalam situasi yang diberikan, apakah benar jika dilakukan dalam dua langkah? Jika itu adalah hal yang benar untuk dilakukan, apa manfaat tambahan untuk melakukannya dalam dua langkah?
Kaz

@Kaz - karena rebase tidak otomatis. Mengambil perubahan terlebih dahulu memungkinkan Anda melakukan penilaian. Itu tidak memperbaiki masalah dengan riwayat rebasing yang sudah Anda dorong. Ini akan memungkinkan Anda untuk melihat apakah aman untuk melakukan rebase perubahan yang belum Anda dorong.
Justin Ohms

2
@JustinOhms Bagaimana Anda memutuskan apakah aman untuk melakukan rebase perubahan? Saya hanya akan mencoba git rebase, dan mundur jika itu membuat berantakan, dalam hal ini saya mungkin juga melakukan git pull --rebase. Tapi mungkin Anda punya cara lain?
Kaz

3
@KaZ gitk memungkinkan Anda melihat struktur cabang secara visual. Ini akan menunjukkan posisi kepala lokal Anda, remote, dan struktur cabang Anda dalam kaitannya dengan apa yang telah Anda ambil. Dengan cara ini Anda dapat memastikan bahwa Anda tidak rebasing perubahan yang diambil yang didasarkan pada leluhur yang sebelum apa yang telah Anda mendorong ke remote Anda.
Justin Ohms

Gunakan rebasesaat Anda bekerja pada cabang lokal yang belum didorong. Jika Anda bekerja pada cabang yang ada di remote, rebasedapat mengakibatkan beberapa masalah buruk sehingga Anda harus memilih yang biasa merge.
Justus Romijn

151

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

git pull dan git fetch


10
Jika Anda suka gambarnya maka lihatlah lembar contekan git, yang merupakan jenis yang sama untuk semua perintah git ... ndpsoftware.com/git-cheatsheet.html
Tom

3
Tidakkah klon juga memengaruhi repositori lokal (menyalin semua riwayat dari jarak jauh)?
Tom Loredo

135

masukkan deskripsi gambar di sini

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


18
Teman-teman, klik tautan untuk berinteraksi dengan berbagai kolom. Cheatsheet ini adalah sumber terbaik yang saya lihat untuk sepenuhnya memahami perbedaan antara setiap perintah.
M. Luisa Carrión

Jawaban ini harus ke atas
Tessaracter

126

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


4
Tip yang bagus, meskipun perlu disebutkan untuk pengguna git baru yang rebase memodifikasi hash komit (saya menemukan bahwa mengejutkan berasal dari subversi).
AlexMA

1
Bisakah Anda menjelaskan apa perbedaan antara git pulldan git pull --rebase?
shaijut

2
Lihat peringatan nyata tentang metode ini dalam jawaban di atas: stackoverflow.com/a/6011169/241244

118

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

Bukankah a git pulljuga melakukan penggabungan, yaitu pergi ke copy pekerjaan?
Kamiel Wanrooij

Poin bagus, ya itu akan menempatkan semua perubahan dalam copy pekerjaan Anda, dan kemudian Anda bisa mengkomitnya sendiri ke repo lokal. Saya akan memperbarui visual.
Justus Romijn

@JustusRomijn Bukankah tarik juga memperbarui repositori lokal? Tidakkah seharusnya ada tanda bintang antara tempat asli dan tanda bintang kerja?
user764754

2
@ user764754 Saat Anda menarik, copy pekerjaan Anda mendapatkan perubahan (mungkin juga ada beberapa konflik yang mungkin perlu Anda selesaikan). Anda masih harus memasukkannya ke dalam repositori lokal Anda.
Justus Romijn

@JustusRomijn: Terima kasih atas ilustrasinya. Akan sangat bagus jika Anda dapat membuat diagram lebih komprehensif dengan menggambarkan efek operasi seperti reset, cherry pick pada status repositori.
jith912

106

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.


Tidak terlalu sulit untuk dibaca: kotak mewakili status repo, bahwa di setiap baris berubah waktu dari kiri ke kanan setelah operasi yang dilaporkan di baris 2 kotak. Label R0n adalah tag di git, dan tag dengan tanda + adalah hal yang belum dikomit. Sanbox digunakan untuk folder kerja Anda, yang berbeda dari folder repo, tempat barang-barang yang disimpan disimpan.
user1708042

96

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)

masukkan deskripsi gambar di sini

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.

masukkan deskripsi gambar di sini

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.

masukkan deskripsi gambar di sini

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

masukkan deskripsi gambar di sini

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.

masukkan deskripsi gambar di sini


1
jika Anda bisa mengubah 'Cabang Utama' menjadi 'Remote Repo', itu akan menjadi jawaban yang bagus.
Qibiron Who

87

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.


3
Saya lebih suka mengatakan git pull == git fetch + git merge:)
melvynkim

2
Tapigit pull --rebase = git fetch + git rebase
Tino

83

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 .


78

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.


73

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.


51

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


1
Dan tidak ada gunanya jika git mengira Anda berada di belakang dengan komitmen dan dapat "mempercepat", yang pada akhirnya saya menyelesaikan rm -rfsemuanya dan memulai dari awal. Bodoh Git, tolong biarkan saya mendapatkan yang terbaru sehingga saya dapat kembali bekerja?
Chris K

47

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

masukkan deskripsi gambar di sini


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


1
Saya suka jawaban ini
Kid_Learning_C

44

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


37

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.


37

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.


35

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


34

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.


33

Representasi Grafis sederhana untuk Pemula,

masukkan deskripsi gambar di sini

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.


Grafik yang bagus, tetapi Anda mungkin ingin menjelaskan mengapa Anda menggunakan "rebase" ketika grafik mengatakan "bergabung".
Guntram Blohm mendukung Monica

2
menggabungkan akan mewakili komit cabang lain dan menghasilkan komit baru yang berisi komit sebagai referensi. tetapi rebase akan mereplikasi komit dari cabang lain yang tidak akan membuat komit baru daripada mereplikasi
Mohideen bin Mohammed

33

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.

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.
Judi bola