Git Stash Pop: Pertahankan Pekerjaan Saat Berpindah Cabang

Jika Anda punya pekerjaan yang setengah jadi dan belum siap untuk di-commit, tetapi harus segera berganti konteks, jangan buat commit "WIP". Juga, jangan salin-tempel perubahan Anda ke file teks seperti tahun 2005. git stash sudah lebih dari cukup.

Perintah ini adalah cara andalan untuk menyimpan pekerjaan yang belum di-commit saat Anda berganti konteks. Ini memungkinkan Anda menyimpan perubahan sementara, menangani tugas mendesak di cabang lain, dan memulihkan semuanya persis di tempat Anda tinggalkan.

Dalam artikel ini, saya akan memandu Anda tentang cara kerja git stash pop, kapan menggunakannya alih-alih git stash apply, dan cara memulihkan saat konflik tak terelakkan muncul.

Jika Anda baru mengenal Git dan merasa konsep stash membingungkan, pastikan untuk menguasai dasarnya terlebih dahulu. Kursus Introduction to Git dan Introduction to GitHub kami akan membuat Anda cepat mahir.

Memahami Git Stash

Git stash adalah penyimpanan sementara untuk perubahan yang belum di-commit.

Anggap saja sebagai clipboard untuk pekerjaan Anda. Anda memiliki perubahan di working directory yang belum siap di-commit, tetapi perlu beralih cabang atau menarik pembaruan dari remote. Jadi alih-alih kehilangan pekerjaan atau membuat commit WIP, Anda melakukan stash.

Perintah ini menyimpan modifikasi Anda dan mengembalikan working directory agar sesuai dengan commit HEAD.

Gagasan stashing di Git

Stashing memecahkan masalah sederhana: Git tidak mengizinkan Anda berganti cabang dengan perubahan yang belum di-commit.

Misalnya Anda sedang mengerjakan sebuah fitur ketika laporan bug masuk. Anda perlu beralih ke cabang lain sekarang juga, tetapi Anda punya kode setengah jadi dan file yang dimodifikasi. Commit tidak masuk akal karena pekerjaan Anda belum selesai. Checkout paksa akan membuat perubahan Anda hilang.

Saat itulah Anda melakukan stash.

Berikut skenario paling umum di mana stashing dapat membantu Anda:

1. Beralih cabang untuk pekerjaan mendesak: Anda sedang di tengah pengembangan fitur ketika perlu memperbaiki bug di produksi.
2. Menarik perubahan dari remote: Rekan tim Anda mendorong pembaruan dan Anda perlu pull, tetapi Anda memiliki modifikasi lokal.
3. Menghindari commit berantakan: Anda belum siap untuk commit, tetapi butuh working directory yang bersih untuk rebase atau merge.
4. Menyimpan kode eksperimental: Anda ingin mencoba pendekatan berbeda tanpa kehilangan pekerjaan saat ini

Stashing cepat dan dapat dibalik - tidak perlu memikirkan pesan commit atau nama cabang.

Arsitektur tumpukan stash

Git menyimpan stash dalam tumpukan last-in, first-out (LIFO).

Setiap kali Anda melakukan stash, Git membuat entri baru di puncak tumpukan. Stash terbaru menjadi stash@{0}, dan stash yang lebih lama bergeser ke bawah: stash@{1}, stash@{2}, dan seterusnya.

Di balik layar, setiap stash sebenarnya adalah commit - atau lebih tepatnya, serangkaian commit. Git membuat struktur commit multi-induk yang menyimpan:

1. Perubahan working directory Anda
2. Perubahan yang di-stage (index)
3. File yang tidak terlacak (jika Anda menggunakan flag u)

Struktur ini berarti stash bukan sekadar snapshot. Itu adalah commit lengkap yang dapat di-merge kembali oleh Git ke working directory Anda nanti.

Anda dapat mereferensikan stash dengan dua cara - berdasarkan indeks menggunakan sintaks stash@{0}, atau menggunakan git stash list untuk menemukan pesan yang Anda berikan dan merujuk ke stash spesifik tersebut. Indeks lebih cepat untuk stash terbaru, tetapi pesan lebih baik saat Anda menyimpan banyak stash.

Berikut tampilan tumpukan stash yang umum:

Awalan WIP on berarti Anda menggunakan git stash tanpa pesan. Awalan On berarti Anda memberikan pesan khusus dengan git stash push -m.

Stash hanya ada di repositori lokal Anda - tidak akan didorong ke remote. Ini menjaga pekerjaan sementara Anda tetap di tempat yang semestinya: di mesin Anda, siap dipulihkan saat dibutuhkan.

Membuat, Mengelola, dan Memeriksa Stash

Perintah git stash dasar sudah cukup untuk memulai, tetapi itu cara yang malas. Anda akan berakhir dengan tumpukan entri "WIP on branch-name" yang tidak memberi tahu apa pun tentang isinya. Enam minggu kemudian, Anda tidak ingat stash mana yang berisi perbaikan bug dan mana yang berisi refactor setengah jadi.

Sekarang saya akan menunjukkan cara melakukannya dengan benar sejak awal.

Membuat stash dengan metadata yang tepat

Cara termudah untuk melakukan stash adalah cukup mengetik git stash:

git stashDidukung oleh

Ini menyimpan perubahan Anda, tetapi pesan "WIP on main" tidak terlalu informatif. Anda tidak dapat mengetahui isinya tanpa memeriksanya.

Sebagai gantinya, jalankan git stash push -m dengan pesan deskriptif:

git stash push -m "Updated file.txt"Didukung oleh

Sekarang daftar stash Anda benar-benar informatif:

Perbedaannya jelas. Satu entri memberi tahu Anda persis apa yang dilakukan, sementara yang lain membuat Anda menebak.

Tulis pesan seolah-olah Anda meninggalkan catatan untuk diri Anda di masa depan. "Tambah logika auth", "Perbaiki bug navbar", atau "Eksperimen desain API baru" selalu lebih baik daripada pesan WIP generik.

Menyertakan file yang tidak terlacak atau diabaikan

Secara default, git stash hanya menyimpan file yang terlacak - file yang sudah dikenal Git.

File yang tidak terlacak tetap berada di working directory Anda. Ini sering mengecoh orang saat mereka melakukan stash, berganti cabang, dan melihat file baru mereka masih ada di sana.

Berikut yang terjadi:

echo "new_feature.py" > new_feature.py
git stashDidukung oleh

File tersebut tidak ikut di-stash karena Git belum melacaknya:

Untuk mengatasinya, gunakan flag -u untuk men-stash file yang tidak terlacak:

git stash push -u -m "Added a Python file for a new cool feature"Didukung oleh

Ini akan men-stash file yang terlacak dan tidak terlacak. Working directory Anda menjadi benar-benar bersih.

Tip: Anda dapat menambahkan flag -a untuk menyertakan file yang diabaikan juga. Ini men-stash file terlacak, file tidak terlacak, dan file di .gitignore. Anda jarang membutuhkan ini kecuali saat men-debug masalah build atau ingin menyimpan snapshot yang benar-benar bersih dari semuanya.

Berikut ringkasan agar Anda tahu kapan menggunakan setiap flag:

1. Tanpa flag: Anda hanya mengubah file yang sudah ada

2. u flag: Anda menambahkan file baru yang belum terlacak

3. a flag: Anda perlu menyimpan semuanya, termasuk keluaran build atau file sementara

Sebagian besar waktu, Anda akan menggunakan -u. Itu pilihan paling aman saat Anda membuat file baru selama pengembangan.

Stashing parsial atau selektif

Anda tidak harus men-stash semua yang ada di working directory.

Misal Anda telah memperbaiki dua bug, tetapi hanya ingin men-stash salah satunya. Atau Anda memiliki perubahan di lima file, tetapi hanya tiga yang terkait dengan fitur yang ingin disimpan.

Anda dapat men-stash file tertentu dengan pathspec:

git stash push -m "New files" new_file.txt new_file_2.txtDidukung oleh

Ini hanya men-stash new_file.txt dan new_file_2.txt. Yang lain tetap di working directory Anda.

Anda juga dapat menggunakan wildcard:

git stash push -m "Stash all txt files" *.txtDidukung oleh

Atau, Anda dapat menggunakan --patch untuk stashing interaktif:

git stash push --patchDidukung oleh

Git akan menelusuri setiap perubahan dan bertanya apakah Anda ingin men-stash-nya. Anda menjawab y (ya), n (tidak), atau s (bagi hunk ini menjadi bagian yang lebih kecil).

Ini berguna saat Anda memiliki perubahan terkait dan tidak terkait tercampur dalam file yang sama. Anda men-stash pekerjaan fitur dan meninggalkan kode debug.

Berikut tampilan prompt interaktifnya:

Mendaftar dan memeriksa stash

Seperti yang sudah Anda lihat, Anda dapat menjalankan git stash list untuk melihat semua yang telah Anda stash:

Stash terbaru selalu stash@{0}. Stash yang lebih lama bergeser turun indeks.

Jika Anda menulis pesan yang bagus, Anda dapat memindai daftar ini dan tahu persis isi setiap stash. Jika tidak, Anda harus memeriksanya satu per satu.

Gunakan git stash show untuk melihat ringkasan:

Ini menunjukkan file mana yang berubah dan berapa banyak baris yang ditambahkan atau dihapus.

Atau, gunakan git stash show -p untuk melihat perbedaannya secara lengkap:

Flag -p menampilkan perubahan kode aktual, seperti git diff. Inilah cara Anda memastikan akan mem-pop stash yang tepat sebelum menjalankan git stash pop.

Apa yang Sebenarnya Dilakukan Git Stash Pop

Sekarang mari bahas apa yang sebenarnya dilakukan git stash pop dan mengapa Anda menggunakannya.

Perilaku dasar dan sintaks

Perintah git stash pop melakukan dua hal: menerapkan perubahan yang di-stash dan kemudian menghapus stash tersebut dari tumpukan.

Berikut sintaks dasarnya:

git stash popDidukung oleh

Ini mem-pop stash terbaru (stash@{0}) dan menghapusnya dari daftar stash Anda.

Anda juga dapat mem-pop stash tertentu dengan merujuk indeksnya:

git stash pop stash@{1}Didukung oleh

Ini menerapkan stash@{1} dan menghapusnya, tetapi ada catatan - sisa stash akan bergeser ke atas. Yang sebelumnya stash@{2} menjadi stash@{1}, dan seterusnya.

Cara Git memproses stash pop

Saat Anda menjalankan git stash pop, Git melakukan three-way merge di balik layar.

Git membandingkan tiga keadaan:

1. Commit dasar (saat Anda membuat stash)
2. Commit HEAD Anda saat ini
3. Perubahan yang di-stash

Jika merge berhasil tanpa konflik, Git menerapkan perubahan Anda dan menghapus stash. Working directory Anda terlihat persis seperti sebelum Anda melakukan stash.

Berikut contoh alur kerja sederhana:

# You're working on a feature
echo "new feature code" >> feature.py
git stash push -m "Half-finished feature work"

# Switch to new branch and make unrelated changes
git checkout bugfix
echo "bug fix" >> bugfix.py
git add bugfix.py
git commit -m "Fix critical bug"

# Go back to your other branch
git checkout main

# Pop your stashed work
git stash popDidukung oleh

Jika Git tidak bisa merge dengan bersih, Anda akan mendapat konflik. Stash tetap berada di tumpukan karena pop tidak selesai dengan sukses. Anda akan melihat penanda konflik di file, sama seperti saat konflik merge biasa.

Saat konflik terjadi, Anda perlu menyelesaikannya secara manual, stage file yang sudah diperbaiki, dan commit. Stash tidak otomatis hilang, jadi Anda harus menjalankan git stash drop setelah semuanya terselesaikan.

Menerapkan stash lintas cabang

Stash tidak terikat pada cabang tertentu.

Anda bisa membuat stash di bugfix, beralih ke main, dan mem-pop stash tersebut di sana. Git tidak peduli dari mana stash berasal - Git hanya mencoba menerapkan perubahan ke cabang tempat Anda berada saat ini.

Ini membuka beberapa alur kerja yang berguna:

1. Memindahkan pekerjaan antar cabang: Katakanlah Anda mulai ngoding di cabang yang salah. Alih-alih me-reset dan kehilangan pekerjaan, Anda melakukan stash, berpindah ke cabang yang benar, dan mem-pop di sana.

2. Mengatur ulang tugas: Anda men-stash kode eksperimental seminggu lalu. Sekarang Anda ingin mencobanya di cabang berbeda untuk melihat apakah lebih cocok di sana.

3. Menguji perubahan dalam konteks berbeda: Anda memiliki perbaikan bug yang di-stash, dan ingin mengujinya di beberapa cabang sebelum commit. Gunakan git stash apply alih-alih pop untuk menjaga stash tetap ada, uji di berbagai cabang, lalu pop di cabang tempat Anda ingin melakukan commit. Lebih lanjut tentang apply nanti.

Selama perubahan tidak bertentangan dengan cabang Anda saat ini, stash akan diterapkan dengan bersih - itu ide utama yang harus Anda ingat.

Git Stash Pop vs Git Stash Apply

Pengembang sering bertanya apakah harus menggunakan git stash pop atau git stash apply.

Perbedaan kunci: persistensi stash

Perbedaan utamanya sederhana: pop menghapus stash setelah menerapkannya, sedangkan apply mempertahankannya di tumpukan.

Dengan pop, Anda berkata "Saya sudah selesai dengan stash ini - terapkan dan buang." Dengan apply, Anda berkata "Saya mungkin membutuhkannya lagi nanti."

Ini memengaruhi alur kerja Anda dalam dua hal:

1. Keamanan: Jika sesuatu salah saat pop dan Anda perlu memulihkan, stash sudah hilang. Dengan apply, stash tetap di tumpukan sebagai cadangan.

2. Kerapian: Menggunakan pop menjaga daftar stash Anda tetap bersih secara otomatis. Menggunakan apply berarti Anda harus menjalankan git stash drop secara manual nanti untuk menghapus stash yang sudah selesai.

Kebanyakan pengembang memilih pop karena lebih rapi. Namun apply lebih baik saat Anda tidak yakin stash akan bekerja di cabang saat ini, atau ketika Anda ingin menguji perubahan yang sama di beberapa cabang.

Prediktabilitas, risiko, dan pergeseran indeks

Di sinilah pop menjadi rumit - indeks stash bergeser saat Anda mem-pop dari tengah tumpukan.

Misal Anda memiliki tiga stash:

stash@{0}: Feature work
stash@{1}: Bug fix
stash@{2}: Experimental codeDidukung oleh

Jika Anda mem-pop stash@{1}, sisa stash bergeser ke atas:

stash@{0}: Feature work
stash@{1}: Experimental codeDidukung oleh

Ini dapat menimbulkan masalah jika Anda membuat skrip operasi Git atau menjalankan beberapa perintah pop secara berurutan. Anda mem-pop stash@{1}, lalu mencoba mem-pop stash@{2}, tetapi indeks itu sudah tidak ada.

Perintah apply tidak punya masalah ini. Indeks hanya bergeser saat Anda secara eksplisit menjalankan git stash drop. Anda dapat menerapkan stash dalam urutan apa pun tanpa khawatir tumpukan berubah tanpa sepengetahuan Anda.

Penanganan konflik yang identik

Kedua perintah menangani konflik dengan cara yang sama persis.

Jika Git tidak bisa merge perubahan yang di-stash dengan bersih, Anda akan mendapatkan penanda konflik di file. Perbedaannya adalah apa yang terjadi pada stash:

1. Dengan pop: Stash tetap di tumpukan karena pop tidak selesai dengan sukses

2. Dengan apply: Stash tetap di tumpukan (yang memang akan terjadi)

Dalam kedua kasus, Anda perlu memperbaiki konflik secara manual, stage file yang diselesaikan dengan git add, dan menghapus stash dengan git stash drop (jika menggunakan apply).

Alur kerja penyelesaian konflik identik - satu-satunya perbedaan adalah apakah stash akan dihapus secara otomatis saat sukses.

Kapan memilih masing-masing

Gunakan git stash pop saat:

1. Anda menerapkan stash sekali dan sudah selesai dengannya
2. Anda ingin menjaga daftar stash tetap bersih secara otomatis
3. Anda bekerja pada satu cabang dan tidak butuh stash di tempat lain

Gunakan git stash apply saat:

1. Anda ingin menguji perubahan yang sama di beberapa cabang
2. Anda tidak yakin stash akan bekerja dengan bersih
3. Anda membuat skrip operasi Git dan butuh indeks yang prediktif
4. Anda ingin jaring pengaman jika terjadi sesuatu yang salah

Menangani Konflik pada Stash Pop

Konflik terjadi saat Git tidak bisa menggabungkan perubahan yang di-stash dengan bersih. Di bagian ini, saya akan menunjukkan cara menanganinya.

Kapan konflik terjadi dan mengapa

Konflik terjadi selama three-way merge yang dilakukan Git saat Anda mem-pop stash.

Git membandingkan tiga versi kode Anda:

1. Commit dasar saat Anda membuat stash
2. Commit HEAD Anda saat ini
3. Perubahan yang di-stash

Jika baris yang sama berubah di cabang Anda saat ini dan di stash, Git tidak tahu versi mana yang harus dipertahankan. Itulah konflik.

Penyebab umum konflik stash pop:

1. Anda memodifikasi file yang sama di kedua cabang: Anda men-stash perubahan pada sebuah file, beralih cabang, lalu mengedit file yang sama lagi sebelum mem-pop
2. Orang lain mendorong perubahan: Anda men-stash pekerjaan, menarik pembaruan dari remote, dan pembaruan tersebut menyentuh kode yang sama
3. Anda melakukan rebase atau cherry-pick commit: Commit dasar yang diharapkan Git sudah tidak ada lagi, yang menyebabkan ketidakcocokan merge

Intinya, semakin lama sebuah stash dibiarkan, semakin besar kemungkinan Anda akan menemui konflik saat akhirnya mem-pop-nya.

Alur kerja penyelesaian konflik

Saat konflik terjadi, Git menghentikan pop dan memberi tanda konflik pada file Anda:

File Anda sekarang berisi penanda konflik:

Semua yang berada di antara <<<<<<< Updated upstream dan ======= adalah kode Anda saat ini. Semua yang berada di antara ======= dan >>>>>>> Stashed changes berasal dari stash.

Berikut yang bisa Anda lakukan untuk memperbaikinya:

1. Buka file yang berkonflik dan putuskan versi mana yang akan dipertahankan (atau gabungkan keduanya)

2. Hapus penanda konflik (<<<<<<<, =======, >>>>>>>)

3. Stage file yang sudah diselesaikan dengan git add

4. Hapus stash secara manual dengan git stash drop - ingat bahwa stash tidak akan hilang otomatis.

Strategi alternatif

Jika Anda tidak ingin berurusan dengan konflik di cabang saat ini, gunakan git stash branch sebagai gantinya.

Perintah ini membuat cabang baru dari commit saat Anda membuat stash, lalu menerapkan stash di sana:

git stash branch temp-featureDidukung oleh

Git membuat cabang bernama temp-feature, melakukan checkout, dan mem-pop stash Anda ke sana. Karena cabang dimulai dari commit yang persis sama dengan saat Anda melakukan stash, tidak akan ada konflik. Saya akan membahas ini lebih dalam di bagian terpisah.

Anda juga dapat membatalkan pop yang gagal dengan git reset --merge:

git stash pop

# Conflicts appear

git reset --mergeDidukung oleh

Ini membatalkan upaya pop dan mengembalikan working directory ke keadaan sebelum pop. Stash tetap ada di tumpukan.

Membatalkan operasi stash yang sedang berlangsung

Jika Anda memulai pop atau apply dan ingin benar-benar mundur, ada beberapa opsi.

Untuk konflik yang belum mulai Anda perbaiki, jalankan berikut ini:

git reset --mergeDidukung oleh

Ini membatalkan merge dan membersihkan working directory Anda. Semuanya kembali seperti sebelum Anda menjalankan perintah stash.

Untuk konflik yang sudah sebagian Anda perbaiki, jalankan perintah ini:

git reset --hard HEADDidukung oleh

Ini membuang semua perubahan di working directory, termasuk perbaikan apa pun yang sudah Anda buat. Gunakan saat Anda membuat kekacauan dan ingin memulai dari awal.

Ingat bahwa perintah ini menghancurkan pekerjaan yang belum di-commit. Pastikan Anda benar-benar ingin membuang semuanya sebelum menjalankannya.

Setelah membatalkan, stash Anda masih ada di tumpukan (kecuali Anda menggunakan pop dan berhasil sebelum terjadi konflik). Anda dapat mencoba lagi nanti, atau gunakan git stash branch untuk pendekatan yang lebih bersih.

Membersihkan Stash

Stash cepat menumpuk di proyek yang berumur panjang. Anda men-stash pekerjaan untuk memperbaiki bug, lalu melupakannya. Anda membuat stash eksperimental yang tidak pernah dipop. Enam bulan kemudian, Anda memiliki 20 stash dan tidak tahu separuh isinya.

Ini membuat lebih sulit menemukan stash yang benar-benar Anda butuhkan. Anda akhirnya menjalankan git stash show -p pada masing-masing hanya untuk mengetahui isinya.

Ini membuang-buang waktu besar, jadi ingatlah untuk membersihkan stash Anda secara berkala.

Menghapus stash individual

Gunakan git stash drop untuk menghapus stash tertentu:

git stash drop stash@{2}Didukung oleh

Ini menghapus stash@{2} dari tumpukan Anda. Sisa stash bergeser ke atas - yang sebelumnya stash@{3} menjadi stash@{2}.

Anda juga dapat menghapus stash terbaru tanpa menyebutkan indeks:

git stash dropDidukung oleh

Ini menghapus stash@{0} secara default.

Selama bertahun-tahun bekerja dengan Git, alasan utama saya menghapus stash adalah ketika:

1. Anda menyadari tidak lagi membutuhkan perubahan tersebut
2. Anda memiliki stash duplikat (lebih sering terjadi daripada yang Anda kira)
3. Sebuah stash sudah sangat lama hingga Anda tidak ingat lagi untuk apa

Jika Anda tidak yakin apakah akan menghapus stash, gunakan git stash show -p untuk memeriksanya terlebih dahulu. Lebih baik aman daripada menyesal.

Mengosongkan seluruh tumpukan stash

Anda dapat menggunakan git stash clear untuk menghapus semua stash sekaligus:

git stash clearDidukung oleh

Ingatlah bahwa ini bersifat permanen. Anda tidak dapat membatalkannya atau memulihkan stash setelahnya.

Hanya gunakan git stash clear saat Anda benar-benar yakin tidak membutuhkan salah satu dari pekerjaan yang di-stash.

Sebagian besar waktu, lebih baik menghapus stash satu per satu agar Anda tidak sengaja menghapus sesuatu yang Anda butuhkan.

Membuat Cabang dari Stash

Terkadang solusi terbersih adalah mengubah stash menjadi cabang tersendiri. Ini menghindari konflik merge dan memberi rumah yang layak untuk pekerjaan yang di-stash.

Menggunakan git stash branch

Perintah git stash branch membuat cabang baru dan menerapkan stash Anda ke sana:

Berikut yang terjadi:

1. Git membuat cabang baru bernama feature-experiment dari commit saat Anda membuat stash

2. Git melakukan checkout cabang baru tersebut

3. Git mem-pop stash ke cabang tersebut

4. Git menghapus stash dari tumpukan Anda (seperti pop)

Karena cabang dimulai dari commit yang persis sama dengan stash, tidak akan ada konflik. Perubahan diterapkan dengan bersih setiap saat.

Anda juga dapat menggunakan stash tertentu alih-alih yang terbaru:

git stash branch new-feature stash@{2}Didukung oleh

Kasus penggunaan umum

Membuat cabang dari stash sangat cocok untuk fitur eksperimental. Misalnya Anda men-stash kode eksperimental seminggu lalu, dan sekarang ingin mengembangkannya dengan benar tanpa mengacaukan pekerjaan saat ini.

Anda mendapatkan cabang bersih untuk mengerjakan eksperimen. Jika berhasil, Anda merge kembali. Jika tidak, Anda hapus cabangnya dan lanjutkan.

Ini juga bagus untuk rebase yang panjang. Alih-alih menangani potensi konflik selama rebase, Anda bisa men-stash semuanya dan membuat cabang darinya.

git stash push -m "WIP before rebase"
git rebase main
git stash branch temp-workDidukung oleh

Sekarang Anda dapat meninjau perubahan yang di-stash secara terpisah dan memutuskan bagaimana mengintegrasikannya setelah rebase.

Membuat cabang juga berguna untuk mengisolasi perubahan besar atau berantakan. Bayangkan Anda memiliki stash besar dengan perubahan di 15 file, separuhnya bertentangan dengan cabang saat ini. Cukup buat cabang baru - tidak perlu berjuang menyelesaikannya.

Anda mendapatkan cabang khusus di mana Anda dapat meninjau semuanya dengan tenang, melakukan commit dengan benar, lalu menggabungkannya kembali dengan riwayat yang jelas.

Teknik Lanjutan dan Opsi Pemulihan

Sekarang Anda sudah akrab dengan dasar-dasar git stash, jadi saya akan menunjukkan beberapa konsep yang lebih lanjut.

Bekerja dengan entri stash spesifik

Anda dapat mem-pop atau menerapkan stash mana pun di tumpukan, bukan hanya yang terbaru.

Cukup referensikan stash berdasarkan indeksnya untuk mengambil yang Anda butuhkan:

git stash pop stash@{3}
git stash apply stash@{1}Didukung oleh

Ini memungkinkan Anda mengambil stash yang lebih lama tanpa menyentuh yang lebih baru. Saat Anda mem-pop stash di tengah, semua indeks di bawahnya bergeser ke atas. Yang sebelumnya stash@{4} menjadi stash@{3}, dan seterusnya. Jika Anda membuat skrip operasi Git atau mem-pop beberapa stash secara berurutan, pergeseran indeks ini akan merusak perintah Anda.

Solusinya adalah menggunakan apply alih-alih pop saat Anda membutuhkan indeks yang prediktif:

git stash apply stash@{2}

# Drop it manually when you're done
git stash drop stash@{2}Didukung oleh

Ini memberi Anda kontrol penuh kapan tumpukan berubah. Anda menerapkan stash, memverifikasi bahwa semuanya bekerja dengan benar, lalu menghapusnya sendiri. Indeks hanya bergeser saat Anda secara eksplisit memerintahkannya.

Memulihkan status staged

Secara default, git stash pop dan git stash apply memulihkan perubahan Anda tetapi tidak mempertahankan apa yang di-stage.

Misal Anda mengubah tiga file, dan Anda men-stage dua di antaranya untuk commit sebelum melakukan stash. Saat Anda mem-pop stash itu, ketiga file kembali sebagai perubahan yang belum di-stage. Git kehilangan jejak file mana yang ingin Anda commit.

Solusinya adalah menggunakan flag --index untuk memulihkan status staging persis seperti sebelumnya:

git stash pop --indexDidukung oleh

Ini merekonstruksi working tree dan index Anda persis seperti sebelum stash. File yang di-stage tetap di-stage. File yang belum di-stage tetap belum di-stage. Semuanya kembali persis seperti semula.

Anda akan membutuhkan flag ini ketika:

1. Anda sedang menyiapkan commit yang di-stage dengan cermat dan tidak bisa kehilangan informasi staging tersebut

2. Anda bekerja dengan skenario staging yang kompleks, seperti saat Anda menggunakan git add -p untuk men-stage hanya hunk tertentu dari file

3. Anda ingin working directory terlihat persis seperti sebelum Anda melakukan stash, tanpa pengecualian

Sebagian besar waktu, Anda tidak membutuhkan flag ini. Anda akan mem-pop stash, melihat apa yang kembali, dan men-stage apa yang diperlukan.

Memulihkan dari kesalahan stash

Pada akhirnya Anda akan menghapus stash yang Anda butuhkan atau mengosongkan seluruh tumpukan secara tidak sengaja.

Jika itu terjadi, reflog Git bisa menyelamatkan hari Anda.

Reflog melacak setiap perubahan referensi di repositori Anda, termasuk stash. Saat Anda membuat atau menghapus stash, Git mencatatnya di reflog. Bahkan setelah Anda menghapus stash, commit tersebut masih ada sementara sebagai objek yang tidak terjangkau.

Anda dapat menemukan stash yang hilang dengan mencari commit yang tidak terjangkau:

git fsck --unreachable | grep commitDidukung oleh

Sekarang Anda dapat memeriksa setiap commit untuk menemukan stash Anda:

git show 066ded985342e585bc8e75c074add99ec1950f50Didukung oleh

Lihat diff dan pesan commit untuk mengidentifikasi mana yang merupakan stash yang hilang. Setelah menemukan commit yang tepat, pulihkan:

git stash apply 066ded985342e585bc8e75c074add99ec1950f50Didukung oleh

Ini menerapkan stash yang hilang ke working directory Anda seolah-olah tidak pernah dihapus.

Lebih baik lagi, cegah kesalahan sejak awal dengan mengikuti praktik terbaik ini:

1. Tulis pesan stash yang deskriptif agar Anda tahu persis apa yang Anda hapus. "Perbaiki bug login" lebih baik daripada "WIP" saat Anda melihat daftar lima stash.

2. Gunakan git stash show -p sebelum menghapus untuk memastikan itu stash yang benar. Luangkan lima detik untuk verifikasi ketimbang lima menit untuk pemulihan.

3. Bersihkan tumpukan stash Anda secara berkala agar tidak berantakan. Tumpukan dengan tiga stash relevan lebih mudah dinavigasi daripada dengan 15 entri lama.

4. Gunakan apply alih-alih pop saat Anda tidak 100% yakin ingin menghapus stash. Anda selalu bisa menghapusnya nanti setelah memverifikasi semuanya berfungsi.

Pemulihan lewat reflog memang bisa, tetapi melelahkan. Lihat saja gambar di atas untuk melihat berapa banyak commit yang harus saya periksa secara manual - dan ini adalah proyek kecil yang dibuat hanya untuk keperluan artikel ini.

Praktik Terbaik dan Pedoman Alur Kerja

Menggunakan stash dengan baik berarti mengikuti pola yang mencegah kesalahan dan menjaga alur kerja tetap rapi. Berikut pendekatan andalan saya.

Pola alur kerja yang direkomendasikan

Alur kerja stash paling aman mengikuti pola sederhana: stash dengan pesan, ganti konteks, lalu pop saat Anda siap melanjutkan.

# Work on feature-branch
git stash push -m "Feature work in progress"

git checkout main
# Do urgent work on main

# Go back
git checkout feature-branch
git stash popDidukung oleh

Ini bekerja untuk sebagian besar situasi. Anda menyimpan pekerjaan, menangani interupsi, dan memulihkan semuanya dengan bersih.

Pola umum lainnya adalah alur kerja "periksa sebelum pop". Anda daftar stash, memeriksa isinya, lalu mem-pop yang tepat.

git stash list
git stash show -p stash@{1}
git stash pop stash@{1}Didukung oleh

Langkah verifikasi ekstra ini mencegah Anda mem-pop stash yang salah atau menerapkan pekerjaan yang sudah usang.

Beberapa pengembang lebih suka alternatif "commit enggan" ketimbang stashing. Alih-alih men-stash, mereka membuat commit sementara dengan pesan seperti "WIP - belum siap" lalu amend atau reset nanti. Ini berfungsi jika Anda kurang nyaman dengan stash atau jika Anda ingin pekerjaan tersebut tercatat di riwayat cabang. Kekurangannya, Anda akan berakhir dengan log commit berantakan jika lupa membersihkannya.

Integrasi dengan alat pengembangan

Kebanyakan GUI Git menampilkan stash Anda secara visual dan memungkinkan Anda mem-pop atau menerapkannya dengan sekali klik.

Alat seperti GitKraken, Sourcetree, dan GitHub Desktop menampilkan stash Anda di sidebar. Anda dapat melihat pesan, memeriksa diff, serta menerapkan atau menghapus stash tanpa mengetik perintah. Ini berguna saat Anda memiliki banyak stash dan ingin membandingkannya berdampingan.

Ekstensi Git di VS Code menampilkan stash di panel kontrol sumber. Anda dapat klik kanan untuk pop, apply, atau drop tanpa meninggalkan editor.

Alias shell membuat stashing lebih cepat jika Anda lebih suka command line. Tambahkan ini ke .bashrc atau .zshrc Anda:

alias gst='git stash'
alias gstp='git stash pop'
alias gstl='git stash list'
alias gsts='git stash show -p'Didukung oleh

Sekarang gst men-stash pekerjaan Anda, gstp mem-pop-nya, gstl menampilkan daftar stash Anda, dan gsts menampilkan diff. Anda menghemat beberapa ketukan tombol setiap kali.

Kebersihan stash dan pertimbangan tim

Stash bersifat lokal di mesin Anda - tidak pernah didorong ke repositori remote.

Artinya rekan tim Anda tidak bisa melihat stash Anda, dan Anda tidak bisa mengaksesnya dari komputer lain. Jika Anda perlu berbagi pekerjaan yang sedang berlangsung, jangan men-stash-nya. Gunakan patch atau cabang sementara sebagai gantinya.

Untuk berbagi pekerjaan melalui patch, jalankan berikut ini:

git stash show -p > my-work.patch
# Send the patch file to your teammate
# They apply it with: git apply my-work.patchDidukung oleh

Sekarang kirim file patch ke rekan tim Anda, dan mereka akan menerapkannya dengan menjalankan git apply my-work.patch.

Untuk berbagi pekerjaan melalui cabang sementara, jalankan ini:

git checkout -b temp/work-in-progress
git add .
git commit -m "WIP - authentication feature"
git push origin temp/work-in-progressDidukung oleh

Rekan tim Anda dapat menarik cabang tersebut, meninjau pekerjaan, dan melanjutkan dari sana.

Apa pun pendekatan andalan Anda, selalu jaga kebersihan stash. Ini akan mencegah kebingungan dan menjaga tumpukan lokal tetap terkelola. Berikut beberapa praktik baik untuk diikuti:

1. Gunakan nama yang deskriptif untuk setiap stash. "Tambah logika autentikasi pengguna" memberi tahu isi di dalamnya. "WIP on feature-branch" tidak memberi tahu apa pun.

2. Bersihkan stash Anda setiap minggu. Jalankan git stash list dan hapus apa pun yang lebih lama dari seminggu. Jika Anda tidak membutuhkannya dalam tujuh hari, kemungkinan besar Anda tidak akan membutuhkannya sama sekali.

3. Jangan biarkan jumlah stash Anda melebihi lima. Lebih dari lima stash berarti Anda menggunakannya sebagai penyimpanan jangka panjang alih-alih penampungan sementara. Pop, commit, atau hapus.

4. Jika Anda bekerja dalam tim dan seseorang bertanya, "Di mana kode yang sedang Anda kerjakan?", jangan pernah menjawab, "Ada di stash saya." Stash bersifat privat dan sementara - bukan untuk berbagi atau mengarsipkan pekerjaan yang penting.

Kesimpulan

Sekarang Anda tahu cara kerja git stash pop dan kapan menggunakannya.

Intinya, stashing itu sederhana: simpan pekerjaan yang belum di-commit, ganti konteks, dan pulihkan nanti. Namun detailnya penting. Mengetahui kapan menggunakan pop versus apply, cara menangani konflik, dan kapan membuat cabang dari stash akan menghemat waktu Anda berjam-jam.

Inti terpentingnya adalah stash adalah penyimpanan sementara, bukan cadangan permanen. Gunakan pesan deskriptif, bersihkan secara berkala, dan jangan biarkan tumpukan Anda tumbuh lebih dari lima entri. Jika Anda perlu berbagi pekerjaan atau menyimpannya jangka panjang, commit ke cabang sebagai gantinya.

Jika Anda menikmati artikel ini dan ingin meningkatkan kemampuan Git, destinasi terbaik berikutnya adalah kursus Intermediate Git dan Intermediate GitHub Concepts kami.