Tutorial Lengkap Menggunakan Git Rebase

Git adalah salah satu sistem kontrol versi yang paling populer di dunia pengembangan perangkat lunak. Salah satu fitur yang sering kali membingungkan tetapi sangat berguna dalam Git adalah rebase. Dalam tutorial ini, kita akan mempelajari secara mendalam tentang Git rebase, cara menggunakannya dengan benar, dan praktik terbaik yang harus diikuti.

Apa itu Git Rebase?

Git rebase adalah perintah yang memungkinkan Anda mengubah sejarah commit dengan memindahkan, menggabungkan, atau memodifikasi rangkaian commit yang ada. Secara sederhana, rebase mengambil satu cabang dan "menempatkannya kembali" di atas cabang lainnya.

Perintah git rebase memiliki fungsi yang mirip dengan git merge, keduanya dirancang untuk mengintegrasikan perubahan dari satu cabang ke cabang lainnya. Namun, keduanya melakukannya dengan cara yang sangat berbeda.

Git Merge vs Git Rebase

Sebelum kita membahas lebih dalam tentang rebase, penting untuk memahami perbedaannya dengan merge:

Git Merge

• Membuat "commit penggabungan" baru yang menghubungkan sejarah kedua cabang
• Tidak merusak atau mengubah commit yang sudah ada
• Menghasilkan struktur cabang yang tidak linear/bercabang
• Lebih aman untuk cabang publik (yang diakses banyak orang)

Git Rebase

• Memindahkan seluruh cabang untuk dimulai dari ujung cabang lain
• Menulis ulang sejarah proyek dengan membuat commit baru untuk setiap commit di cabang asli
• Menghasilkan sejarah proyek yang linear dan bersih
• Ideal untuk cabang pribadi (yang hanya Anda akses)

Cara Kerja Git Rebase

Mari kita lihat bagaimana rebase bekerja dengan contoh. Misalkan Anda sedang mengerjakan fitur baru di cabang bernama feature dan sementara itu seseorang telah memperbarui cabang main dengan commit baru:

      A---B---C (feature)
     /
D---E---F---G (main)

Untuk mengintegrasikan perubahan dari main ke cabang feature, Anda memiliki dua pilihan: merge atau rebase. Jika Anda memilih rebase, perintahnya adalah:

git checkout feature
git rebase main

Setelah rebase, sejarah commit akan terlihat seperti ini:

              A'--B'--C' (feature)
             /
D---E---F---G (main)

Perhatikan bahwa commit A, B, dan C telah dibuat ulang menjadi A', B', dan C'. Commit-commit ini memiliki konten yang sama tetapi hash yang berbeda karena parent commit-nya telah berubah.

Rebase Interaktif

Salah satu fitur paling kuat dari git rebase adalah mode interaktifnya. Dengan rebase interaktif, Anda dapat mengubah commit saat mereka dipindahkan ke cabang baru. Ini sangat berguna untuk membersihkan sejarah commit sebelum menggabungkannya ke cabang utama.

Untuk memulai sesi rebase interaktif, gunakan opsi -i:

git checkout feature
git rebase -i main

Perintah ini akan membuka editor teks yang menampilkan daftar semua commit yang akan dipindahkan:

pick 33d5b7a Pesan untuk commit #1
pick 9480b3d Pesan untuk commit #2
pick 5c67e61 Pesan untuk commit #3

Di editor ini, Anda dapat melakukan berbagai tindakan:

1. pick - gunakan commit apa adanya
2. reword - gunakan commit tetapi ubah pesan commit
3. edit - gunakan commit tetapi berhenti untuk mengubah
4. squash - gabungkan commit dengan commit sebelumnya
5. fixup - seperti squash, tetapi buang pesan commit
6. drop - hapus commit

Misalnya, jika Anda ingin menggabungkan commit kedua ke commit pertama, Anda dapat mengubah:

pick 33d5b7a Pesan untuk commit #1
fixup 9480b3d Pesan untuk commit #2
pick 5c67e61 Pesan untuk commit #3

Setelah menyimpan dan menutup file, Git akan melakukan rebase sesuai dengan instruksi Anda.

Aturan Emas Git Rebase

Ada satu aturan penting dalam penggunaan git rebase yang harus selalu diingat:

Jangan pernah menggunakan rebase pada cabang publik.

Mengapa? Karena rebase menulis ulang sejarah commit. Jika Anda melakukan rebase pada cabang yang juga digunakan oleh orang lain, Git akan menganggap sejarah cabang Anda telah menyimpang dari milik semua orang lain. Sinkronisasi hanya mungkin dilakukan dengan menggabungkan kembali kedua cabang, yang menghasilkan commit penggabungan tambahan dan dua set commit yang berisi perubahan yang sama.

Jadi, sebelum Anda menjalankan git rebase, selalu tanyakan pada diri sendiri: "Apakah ada orang lain yang melihat cabang ini?" Jika jawabannya ya, gunakan cara non-destruktif seperti git merge. Jika tidak, Anda bebas menulis ulang sejarah sesuka hati.

Force Push setelah Rebase

Jika Anda mencoba mendorong (push) cabang yang telah di-rebase ke repositori jarak jauh, Git akan mencegah Anda melakukannya karena bertentangan dengan cabang jarak jauh. Namun, Anda dapat memaksa push dengan flag --force:

git push --force

PERINGATAN: Hati-hati dengan perintah ini! Ini akan menimpa cabang jarak jauh agar sesuai dengan cabang yang di-rebase dari repositori Anda dan dapat membingungkan anggota tim Anda.

Salah satu kasus dimana force-push dapat digunakan adalah ketika Anda melakukan pembersihan lokal setelah Anda mendorong cabang fitur pribadi ke repositori jarak jauh (misalnya untuk tujuan backup). Ini seperti mengatakan, "Ops, saya tidak benar-benar ingin mendorong versi asli cabang fitur itu. Gunakan yang saat ini saja."

Alur Kerja Menggunakan Git Rebase

Berikut adalah beberapa skenario di mana rebase dapat diintegrasikan ke dalam alur kerja Git Anda:

1. Pembersihan Lokal

Cara terbaik untuk memanfaatkan rebase adalah membersihkan commit lokal yang sedang berlangsung. Dengan melakukan rebase interaktif secara berkala, Anda dapat memastikan setiap commit di cabang fitur Anda fokus dan bermakna.

git checkout feature
git rebase -i HEAD~3  # Rebase 3 commit terakhir

2. Mengintegrasikan Perubahan dari Cabang Utama

Ketika Anda sedang mengerjakan cabang fitur dan ingin mengintegrasikan perubahan terbaru dari cabang utama:

git checkout feature
git rebase main

3. Sebelum Membuat Pull Request

Sangat baik untuk membersihkan kode Anda dengan rebase interaktif sebelum membuat pull request:

git checkout feature
git rebase -i main
git push --force-with-lease  # Lebih aman daripada --force

4. Setelah Pull Request Disetujui

Setelah fitur disetujui, Anda dapat melakukan rebase fitur ke ujung cabang utama sebelum menggunakan merge:

git checkout feature
git rebase main
git checkout main
git merge feature  # Ini akan melakukan fast-forward

Praktik Terbaik Git Rebase

1. Jangan pernah rebase cabang publik - Hanya lakukan rebase pada cabang pribadi yang hanya Anda kerjakan.

2. Komunikasikan dengan tim Anda - Jika Anda menggunakan rebase, pastikan semua anggota tim memahami strategi Anda.

3. Gunakan --force-with-lease bukan --force - Ini lebih aman karena akan gagal jika ada commit baru di remote yang belum Anda pull.

4. Selalu pastikan Anda di cabang yang benar - Periksa dua kali cabang aktif sebelum melakukan rebase.

5. Backup sebelum rebase yang rumit - Jika tidak yakin, buat cabang sementara:
   

   git checkout feature
   git checkout -b feature-backup
   git checkout feature
   git rebase -i main

1. Gunakan git reflog untuk memulihkan kesalahan - Jika sesuatu berjalan salah, git reflog dapat membantu Anda menemukan commit sebelum rebase.

Kesimpulan

Git rebase adalah alat yang kuat untuk mempertahankan sejarah commit yang bersih dan linear. Meskipun awalnya tampak rumit, dengan pemahaman yang baik tentang cara kerjanya dan kapan harus menggunakannya, rebase dapat menjadi tambahan yang berharga untuk alur kerja Git Anda.

Ingat aturan emasnya: jangan pernah rebase cabang publik. Selama Anda mengikuti aturan ini, Anda dapat memanfaatkan kekuatan rebase untuk membuat sejarah proyek yang lebih rapi dan mudah diikuti.

Sebagai kesimpulan, tidak ada pendekatan yang benar atau salah antara merge dan rebase. Keduanya adalah alat yang valid dengan kelebihan dan kekurangan masing-masing. Yang terpenting adalah Anda dan tim Anda konsisten dalam pendekatan yang dipilih dan memahami konsekuensi dari setiap metode.

Semoga tutorial ini membantu Anda memahami dan mulai menggunakan git rebase dengan percaya diri dalam proyek-proyek Anda!