git fetch dan git pull: apa bedanya dan mana yang dipilih

Jawaban singkat

git fetch mengunduh commit baru dari server dan memperbarui referensi branch remote (origin/main, origin/feature-x), tetapi tidak mengubah branch aktif maupun berkas di direktori kerja. git pull adalah git fetch ditambah langsung menggabungkan hasilnya ke branch aktif, baik lewat merge (default) maupun rebase.

Dari sini muncul aturan praktis: fetch boleh dijalankan kapan saja karena tidak merusak apa pun. Pull mengubah branch Anda dan bisa berakhir dengan konflik, jadi jalankan dengan direktori kerja yang bersih dan sudah tahu apa yang akan datang.

Di mana branch remote disimpan

Agar perbedaannya jelas, perlu dipahami bahwa di repositori lokal ada dua jenis branch. Branch lokal seperti main atau feature-x digerakkan oleh commit Anda sendiri. Branch pelacakan remote seperti origin/main adalah penanda «begini kondisi server pada saat sinkronisasi terakhir». Penanda ini tidak bisa digeser secara manual; hanya komunikasi dengan server yang memperbaruinya, yaitu fetch, pull, dan push.

git branch -a
* main
  remotes/origin/HEAD -> origin/main
  remotes/origin/main
  remotes/origin/feature-x

git status membandingkan branch Anda dengan penanda origin/main, bukan dengan server yang sebenarnya. Karena itu pesan «Your branch is up to date with 'origin/main'» bisa menyesatkan: jika Anda sudah lama tidak melakukan fetch, Git belum tahu tentang commit baru dari rekan tim.

Apa yang dilakukan git fetch

$ git fetch
remote: Enumerating objects: 7, done.
remote: Counting objects: 100% (7/7), done.
Unpacking objects: 100% (4/4), done.
From github.com:team/project
   3f2a1c9..8b7d4e2  main       -> origin/main

Baris terakhir menjelaskan intinya: penanda origin/main berpindah dari 3f2a1c9 ke 8b7d4e2. Branch main Anda tetap di tempatnya. Sekarang Anda bisa melihat dengan tenang apa yang datang:

git status                       # Your branch is behind 'origin/main' by 2 commits
git log main..origin/main --oneline   # commit yang belum Anda miliki
git diff main origin/main        # apa yang akan berubah di berkas

Varian fetch yang berguna:

• git fetch --all — mengambil perubahan dari semua remote (berguna jika fork memiliki origin dan upstream);
• git fetch --prune (-p) — menghapus penanda cabang lokal yang sudah tidak ada di server;
• git fetch origin main — hanya mengambil satu branch;
• git fetch --tags — sekalian mengambil semua tag.

Agar pembersihan (prune) selalu berjalan, aktifkan sekali saja: git config --global fetch.prune true.

Apa yang dilakukan git pull

git pull menjalankan dua langkah berurutan. Pertama fetch untuk upstream dari branch aktif, lalu menggabungkan origin/<branch> ke branch Anda. Secara harfiah, perintah ini setara dengan:

git fetch origin
git merge origin/main      # atau git rebase origin/main jika memakai pull --rebase

Hasil penggabungan bergantung pada bagaimana kedua riwayat berpisah:

• Anda tidak punya commit baru — terjadi fast-forward, branch hanya dimajukan;
• ada commit baru di Anda dan di server — dengan merge dibuat commit merge, dengan rebase commit Anda diletakkan ulang di atas commit server;
• baris yang sama diubah dari dua sisi — konflik yang harus diselesaikan secara manual.

Perbandingan git fetch dan git pull

git pull: merge atau rebase

Sejak Git 2.27, jika riwayat berpisah dan tidak ada pengaturan eksplisit, pull memberi peringatan. Di versi yang lebih baru, pull berhenti dengan error «Need to specify how to reconcile divergent branches» alih-alih diam-diam melakukan merge. Git meminta Anda memilih strategi sekali saja:

git config --global pull.rebase false   # merge (perilaku default sebelumnya)
git config --global pull.rebase true    # rebase
git config --global pull.ff only        # hanya fast-forward, selain itu ditolak

Merge mempertahankan riwayat apa adanya dan menambahkan commit «Merge branch 'main' of github.com:...». Jika setiap hari melakukan pull ke branch yang punya commit lokal, riwayat akan penuh dengan merge teknis seperti ini.

Rebase memindahkan commit Anda yang belum dikirim ke atas commit terbaru dari server. Riwayat tetap lurus, dan konflik diselesaikan satu commit demi satu. Untuk commit lokal yang belum dipublikasikan, ini biasanya pilihan terbaik. Rebase hanya berbahaya untuk commit yang sudah dikirim dan menjadi dasar kerja orang lain.

ff only adalah mode paling ketat: pull hanya berhasil jika Anda tidak punya commit sendiri. Jika riwayat sudah berpisah, Anda sendiri yang memutuskan langkah berikutnya. Banyak developer berpengalaman memakai mode ini untuk branch utama.

Jika ada perubahan yang belum di-commit di direktori kerja dan pull harus dilakukan sekarang, gunakan git pull --rebase --autostash: Git akan menyimpan perubahan sementara, melakukan rebase, lalu mengembalikannya.

Skenario umum: fetch, lihat dulu, baru gabungkan

Pendekatan «fetch dulu» memberi kendali atas apa yang masuk ke branch Anda. Ini sangat berguna sebelum membuat pull request dan setelah lama tidak bekerja.

git fetch
git log --oneline --graph HEAD origin/main   # bagaimana kedua branch berpisah
git rebase origin/main                       # atau git merge origin/main
git push

Kasus lain yang sering terjadi adalah memperbarui branch fitur dengan main terbaru tanpa berpindah ke main:

git switch feature-x
git fetch
git rebase origin/main

Di sini pull tidak cocok: git pull di branch fitur akan mengambil perubahan dari upstream branch itu sendiri (origin/feature-x), bukan dari branch utama. Anda bisa saja menulis git pull --rebase origin main, tetapi versi dengan fetch lebih jelas.

Sinkronisasi dengan server: menjaga branch tetap mutakhir

Permintaan «git sync» biasanya mengacu pada siklus «ambil perubahan orang lain, kirim perubahan sendiri». Di Git murni tidak ada perintah sync khusus (tombol Sync di IDE dan klien GUI menjalankan pull lalu push). Secara manual, siklus yang andal adalah:

1. git status — pastikan semuanya sudah di-commit atau disimpan dengan git stash;
2. git pull --rebase — ambil perubahan dan letakkan commit Anda di atasnya;
3. selesaikan konflik jika ada: perbaiki berkas, git add, git rebase --continue;
4. jalankan tes;
5. git push.

Untuk menyinkronkan fork dengan repositori asal:

git remote add upstream https://github.com/original/project.git
git fetch upstream
git switch main
git merge --ff-only upstream/main
git push origin main

Masalah umum pada git pull

Your local changes would be overwritten by merge

Pull akan mengubah berkas yang sedang Anda edit tetapi belum di-commit. Pilihannya: commit, simpan dengan git stash (lalu pull dan git stash pop), atau gunakan --autostash. Jangan menghapus perubahan hanya demi menjalankan pull.

Konflik setelah pull

Git berhenti dan menampilkan berkas yang konflik di git status. Buka berkas tersebut, pilih versi yang benar di antara penanda <<<<<<< dan >>>>>>>, lalu git add dan git commit (jika merge) atau git rebase --continue (jika rebase). Jika berubah pikiran, git merge --abort atau git rebase --abort akan mengembalikan semuanya seperti sebelum pull.

There is no tracking information for the current branch

Branch belum memiliki upstream, sehingga Git tidak tahu dari mana harus mengambil. Tentukan secara eksplisit: git pull origin main, atau atur hubungannya sekali saja: git branch --set-upstream-to=origin/main.

refusing to merge unrelated histories

Repositori lokal dan remote dibuat secara terpisah, misalnya di server sudah ada README yang dibuat saat repositori dibuat. Jika Anda yakin keduanya memang harus digabung: git pull origin main --allow-unrelated-histories.

Pull yang gagal: cara membatalkan

Jika merge hasil pull sudah selesai dan hasilnya tidak diinginkan, kembalikan branch ke keadaan sebelum merge dengan git reset --hard ORIG_HEAD. Perintah ini menghapus perubahan yang belum di-commit, jadi periksa git status lebih dulu. Dalam keadaan darurat, posisi branch sebelumnya bisa ditemukan di git reflog.

Mana yang harus dipilih

• Ingin tahu apa yang baru tanpa mengubah apa pun — git fetch.
• Bekerja di branch sendiri dan hanya ingin mengejar server — git pull --rebase (atau pull dengan pull.rebase true yang sudah diatur).
• Memperbarui branch utama tanpa commit sendiri — git pull --ff-only.
• Perlu memasukkan main ke branch fitur — git fetch lalu git rebase origin/main atau git merge origin/main.
• Menulis skrip atau CI — gunakan fetch dan perintah eksplisit, bukan pull.

Bagaimana tampilannya di graf commit

Bayangkan Anda dan rekan memulai dari commit C. Anda membuat commit lokal D, sementara rekan Anda mengirim E ke server. Setelah git fetch, repositori Anda mengenal kedua jalur: main menunjuk ke D, origin/main menunjuk ke E, dan leluhur bersama mereka adalah C.

          D   <- main (HEAD)
         /
A---B---C
         \
          E   <- origin/main

Setelah itu, cara penggabungan yang menentukan. git merge origin/main membuat commit M dengan dua induk, yaitu D dan E. git rebase origin/main menyalin D di atas E sebagai commit baru D' dengan hash berbeda, sehingga riwayatnya menjadi satu garis lurus. git pull menjalankan langkah-langkah ini secara otomatis tanpa jeda. Justru jeda itulah nilai utama fetch yang terpisah: Anda bisa melihat graf sebelum penggabungan dilakukan.

Fetch dan pull di IDE

Di VS Code, IntelliJ IDEA, dan editor lain, tombolnya bernama berbeda, tetapi di baliknya tetap perintah yang sama. «Fetch» berarti git fetch; «Pull» atau «Update Project» berarti pull dengan strategi (merge atau rebase) yang dipilih di pengaturan; «Sync Changes» berarti pull lalu push. Sebelum menekan Sync di branch bersama, pastikan dulu strategi yang aktif, supaya commit merge tidak muncul tanpa diduga. Banyak IDE juga melakukan fetch di latar belakang secara berkala, jadi penghitung commit masuk di status bar biasanya sudah mutakhir.

Ringkasan

git fetch memperbarui pengetahuan Anda tentang server, sedangkan git pull juga menerapkan pengetahuan itu ke branch aktif. Fetch aman kapan saja; pull praktis tetapi mengubah branch dan bisa membawa konflik, jadi atur strateginya sekali dan jaga direktori kerja tetap bersih. Perbedaan push, pull, dan fetch serta cara bekerja dengan remote dan GitHub dibahas dengan praktik dalam kursus Git.