# Git Cheat Sheet

2025-09-1918 min read

Table of Contents

Ini adalah Git Cheat Sheet berisi perintah-perintah Git yang sering digunakan, mulai dari operasi dasar sampai recovery, undo commit, menghapus commit tertentu dari history, rebase, stash, dan berbagai perintah yang berguna saat terjadi kesalahan.

Catatan: Perintah seperti reset --hard, rebase, dan force push dapat menghapus atau menulis ulang history. Pastikan memahami efeknya sebelum digunakan pada branch yang sudah digunakan orang lain.

Sebelum melakukan operasi berisiko, backup branch terlebih dahulu:

git branch backup-before-rewrite

1. Setup dan Konfigurasi Git

Mengatur nama dan email

git config --global user.name "Nama"
git config --global user.email "[email protected]"

Cek konfigurasi

git config --list

Cek konfigurasi tertentu

git config user.name
git config user.email

Mengatur konfigurasi hanya untuk repository saat ini

git config user.name "Nama"
git config user.email "[email protected]"

Mengatur editor default

Contoh menggunakan VS Code:

git config --global core.editor "code --wait"

2. Inisialisasi dan Clone Repository

Membuat repository baru

git init

Clone repository

git clone https://github.com/username/repository.git

Clone ke nama directory tertentu

git clone https://github.com/username/repository.git nama-folder

Clone hanya branch tertentu

git clone --branch <branch> --single-branch <repository-url>

3. Status dan Informasi Repository

Cek status

git status

Versi lebih singkat:

git status -s

Melihat remote

git remote -v

Informasi remote tertentu

git remote show origin

Melihat branch aktif

git branch --show-current

Melihat root directory repository

git rev-parse --show-toplevel

4. Menambahkan File ke Staging Area

Menambahkan file tertentu

git add <file>

Menambahkan beberapa file

git add file1 file2 file3

Menambahkan semua perubahan

git add .

atau:

git add -A

Menambahkan hanya file tracked yang berubah atau dihapus

git add -u

Memilih perubahan secara interaktif

Sangat berguna jika satu file memiliki beberapa perubahan tetapi hanya sebagian yang ingin di-commit.

git add -p

5. Menghapus File dari Git

Menghapus file dari Git dan filesystem

git rm <file>

Menghapus directory

git rm -r <directory>

Berhenti tracking file tetapi mempertahankan file lokal

git rm --cached <file>

Contoh umum ketika .env tidak sengaja di-track:

git rm --cached .env

Kemudian masukkan ke .gitignore.

Berhenti tracking directory tetapi mempertahankan directory lokal

git rm --cached -r <directory>

6. Commit

Membuat commit

git commit -m "Pesan commit"

Membuka editor untuk pesan commit

git commit

Commit semua perubahan file yang sudah tracked

git commit -am "Pesan commit"

-a tidak memasukkan file baru/untracked secara otomatis.

Mengubah pesan commit terakhir

git commit --amend

Atau langsung:

git commit --amend -m "Pesan commit baru"

Menambahkan file yang lupa dimasukkan ke commit terakhir

git add <file>
git commit --amend --no-edit

--no-edit mempertahankan pesan commit sebelumnya.

--amend membuat commit baru dengan hash baru. Hindari menggunakannya pada commit yang sudah dipush dan digunakan orang lain kecuali memang ingin rewrite history.

7. Melihat Riwayat Commit

Riwayat lengkap

git log

Riwayat ringkas

git log --oneline

Riwayat dengan graph branch

git log --oneline --graph --decorate --all

Ini adalah salah satu command paling berguna untuk memahami history repository.

Melihat beberapa commit terakhir

git log --oneline -10

Melihat commit tertentu

git show <commit-id>

Melihat perubahan sebuah file sepanjang history

git log -- <file>

Melihat siapa yang terakhir mengubah setiap baris

git blame <file>

8. Git Diff

Melihat perubahan yang belum di-stage

git diff

Melihat perubahan yang sudah di-stage

git diff --staged

atau:

git diff --cached

Melihat seluruh perubahan terhadap commit terakhir

git diff HEAD

Membandingkan dua commit

git diff <commit-a> <commit-b>

Membandingkan dua branch

git diff <branch-a>..<branch-b>

Melihat hanya nama file yang berubah

git diff --name-only

9. Branch

Melihat branch lokal

git branch

Melihat local dan remote branch

git branch -a

Membuat branch

git branch <nama-branch>

Membuat sekaligus berpindah ke branch baru

Direkomendasikan pada Git modern:

git switch -c <nama-branch>

Bentuk lama yang masih umum:

git checkout -b <nama-branch>

Berpindah branch

git switch <nama-branch>

Kembali ke branch sebelumnya

git switch -

Rename branch saat ini

git branch -m <nama-baru>

Menghapus branch yang sudah di-merge

git branch -d <nama-branch>

Force delete branch

git branch -D <nama-branch>

-D dapat menghapus branch walaupun commit di dalamnya belum di-merge.

10. Merge dan Rebase

Merge branch ke branch saat ini

git merge <nama-branch>

Contoh:

git switch main
git merge feature/login

Batalkan merge yang sedang mengalami conflict

git merge --abort

Rebase branch saat ini

git rebase <nama-branch>

Contoh:

git switch feature/login
git rebase main

Lanjutkan rebase setelah conflict selesai

git add <file>
git rebase --continue

Batalkan rebase

git rebase --abort

11. Interactive Rebase

Interactive rebase sangat berguna untuk memperbaiki history sebelum dipush.

Edit beberapa commit terakhir

Contoh 5 commit terakhir:

git rebase -i HEAD~5

Git akan membuka daftar seperti:

pick a1b2c3d add login
pick b2c3d4e fix login
pick c3d4e5f update README

Beberapa operasi penting:

pick    = pertahankan commit
reword  = ubah pesan commit
edit    = ubah isi commit
squash  = gabungkan dengan commit sebelumnya dan edit pesan
fixup   = gabungkan dengan commit sebelumnya tanpa mempertahankan pesan
drop    = hapus commit

Batalkan interactive rebase

git rebase --abort

Lanjutkan setelah melakukan perubahan

git rebase --continue

12. Remote Repository

Menambahkan remote

git remote add origin https://github.com/username/repository.git

Mengubah URL remote

git remote set-url origin <repository-url>

Fetch perubahan dari remote

git fetch origin

Fetch sekaligus membersihkan remote branch yang sudah dihapus

git fetch --prune

Pull

git pull origin <branch>

Pull menggunakan rebase

git pull --rebase origin <branch>

Push

git push origin <branch>

Push sekaligus mengatur upstream

Biasanya digunakan saat push branch baru pertama kali.

git push -u origin <branch>

Setelah itu cukup:

git push

dan:

git pull

Menghapus branch di remote

git push origin --delete <branch>

13. Stash

Stash digunakan untuk menyimpan perubahan sementara tanpa membuat commit.

Simpan perubahan

git stash

Lebih baik menggunakan pesan:

git stash push -m "WIP login page"

Ikut stash file untracked

git stash -u

Melihat daftar stash

git stash list

Melihat isi stash

git stash show -p

Mengambil stash terakhir sekaligus menghapusnya dari daftar

git stash pop

Mengambil stash tanpa menghapusnya

git stash apply

Mengambil stash tertentu

git stash apply stash@{1}

Menghapus stash tertentu

git stash drop stash@{1}

Menghapus seluruh stash

git stash clear

Membuat branch dari stash

Sangat berguna jika perubahan stash ternyata cukup besar dan ingin dilanjutkan sebagai branch sendiri.

git stash branch <nama-branch> stash@{0}

14. Membatalkan Perubahan File yang Belum Di-commit

Membuang perubahan pada satu file

git restore <file>

Membuang semua perubahan tracked di working directory

git restore .

Perubahan yang dibuang dengan cara ini biasanya tidak mudah dikembalikan.

Mengeluarkan file dari staging tetapi mempertahankan perubahan

git restore --staged <file>

Mengeluarkan semua file dari staging

git restore --staged .

Bentuk lama yang juga sering ditemui:

git reset <file>

Mengembalikan file ke versi commit tertentu

git restore --source=<commit-id> <file>

Contoh:

git restore --source=HEAD~1 package.json

15. Membatalkan Commit Terakhir Tanpa Menghapus Perubahan

Ini salah satu kasus yang paling sering dibutuhkan.

Batalkan commit terakhir tetapi perubahan tetap staged

git reset --soft HEAD~1

Sebelum:

A -- B -- C <-- HEAD

Setelah:

A -- B <-- HEAD

Isi perubahan dari C masih berada di staging area.

Cocok jika:

Salah membuat commit.
Ingin mengubah isi commit.
Ingin memecah commit menjadi beberapa commit.
Ingin menggabungkan ulang commit.

Batalkan commit terakhir dan keluarkan perubahan dari staging

git reset HEAD~1

atau eksplisit:

git reset --mixed HEAD~1

Perubahan file tetap ada, tetapi tidak lagi staged.

Batalkan beberapa commit tetapi pertahankan semua perubahan

Contoh membatalkan 3 commit:

git reset --soft HEAD~3

16. Menghapus Commit Terakhir dan Perubahannya

Jika benar-benar ingin menghilangkan commit terakhir sekaligus perubahan file:

git reset --hard HEAD~1

Untuk dua commit:

git reset --hard HEAD~2

HATI-HATI: --hard membuang perubahan tracked di working tree dan staging area.

Sebelum menjalankannya, sebaiknya cek:

git status
git log --oneline -5

17. Membatalkan Commit yang Sudah Di-push dengan Aman

Jika commit sudah berada di remote dan digunakan orang lain, hindari reset + force push jika tidak benar-benar diperlukan.

Gunakan:

git revert <commit-id>

git revert tidak menghapus commit lama. Git membuat commit baru yang membalik efek commit tersebut.

Contoh:

A -- B -- C -- D
          ^
          commit bermasalah

Setelah:

git revert C

History menjadi:

A -- B -- C -- D -- E
                    ^
                    membalik perubahan C

Revert tanpa langsung membuat commit

git revert --no-commit <commit-id>

Kemudian periksa dan commit sendiri:

git status
git diff
git commit -m "Revert perubahan tertentu"

Revert merge commit

git revert -m 1 <merge-commit-id>

Gunakan dengan hati-hati karena -m menentukan parent utama dari merge.

18. Menghapus Commit Tertentu dari History

Misalnya history:

A -- B -- C -- D -- E
          ^
          ingin dihapus

Jika C ingin dihapus tetapi D dan E tetap dipertahankan, gunakan interactive rebase.

Cara 1: Berdasarkan jumlah commit

git rebase -i HEAD~4

Akan muncul:

pick <hash-B> commit B
pick <hash-C> commit C
pick <hash-D> commit D
pick <hash-E> commit E

Ubah commit yang ingin dihapus menjadi:

pick <hash-B> commit B
drop <hash-C> commit C
pick <hash-D> commit D
pick <hash-E> commit E

Simpan dan tutup editor.

Cara 2: Langsung mulai dari parent commit target

git rebase -i <commit-id>^

Kemudian ubah:

pick <commit-id> ...

menjadi:

drop <commit-id> ...

Menghapus root commit

Jika commit yang ingin diedit berada sejak awal repository:

git rebase -i --root

Jika terjadi conflict

Selesaikan conflict kemudian:

git add .
git rebase --continue

Atau batalkan:

git rebase --abort

Cara ini paling mudah digunakan pada history linear. Rebase pada history merge yang kompleks perlu dilakukan lebih hati-hati.

19. Setelah Menghapus atau Mengubah Commit yang Sudah Di-push

Rebase, amend, dan reset dapat mengubah commit hash.

Jika history lama sudah dipush, push biasa kemungkinan ditolak:

git push

Jika memang yakin ingin mengganti history remote:

git push --force-with-lease origin <branch>

Contoh:

git push --force-with-lease origin main

Gunakan --force-with-lease daripada:

git push --force

karena --force-with-lease memiliki perlindungan tambahan agar tidak sembarangan menimpa update remote yang tidak sesuai dengan kondisi yang diharapkan.

Jangan rewrite history branch bersama seperti main tanpa koordinasi dengan anggota tim.

20. Apakah Commit yang Di-drop Benar-benar Hilang Permanen?

Tidak selalu langsung.

Setelah:

git rebase -i

atau:

git reset --hard

commit mungkin sudah tidak terlihat di history branch, tetapi masih dapat tersimpan sementara di Git object database dan reflog.

Artinya, istilah yang lebih tepat adalah:

menghapus commit dari history branch

bukan menjamin semua salinan commit tersebut langsung hilang secara fisik.

Hal ini justru berguna apabila ternyata commit terhapus secara tidak sengaja.

21. Mengembalikan Commit yang Tidak Sengaja Hilang

Salah satu command penyelamat terpenting di Git:

git reflog

Contoh:

f123abc HEAD@{0}: rebase finished
8ab456d HEAD@{1}: reset: moving to HEAD~2
713ac11 HEAD@{2}: commit: important feature

Jika commit yang hilang adalah:

713ac11

buat branch recovery:

git switch -c recovery 713ac11

Ini lebih aman daripada langsung melakukan reset.

Setelah memastikan commit benar, Anda dapat menggabungkan atau cherry-pick kembali perubahan tersebut.

22. Menghapus File Rahasia dari Seluruh Git History

Jika password, API key, private key, .env, atau secret sudah pernah masuk repository, sekadar:

git rm <file>

atau:

git revert <commit>

tidak menghilangkan secret dari commit sebelumnya.

Untuk rewrite seluruh history, salah satu tool yang direkomendasikan adalah git-filter-repo.

Contoh menghapus file tertentu dari history:

git filter-repo --invert-paths --path path/to/secret-file

Untuk kasus sensitive data pada versi git-filter-repo terbaru dapat digunakan:

git filter-repo \
  --sensitive-data-removal \
  --invert-paths \
  --path path/to/secret-file

git-filter-repo adalah tool terpisah dan mungkin perlu di-install terlebih dahulu.

Jika secret sudah ter-push, rotate/revoke secret tersebut terlebih dahulu. Menghapus history saja tidak menjamin secret belum pernah disalin, di-cache, atau digunakan orang lain.

Rewrite sensitive data juga membutuhkan koordinasi dengan seluruh collaborator karena clone atau fork lama dapat membawa history tersebut kembali.

23. Cherry-pick

Cherry-pick digunakan untuk mengambil commit tertentu dari branch lain.

git cherry-pick <commit-id>

Contoh:

git switch main
git cherry-pick a1b2c3d

Cherry-pick beberapa commit

git cherry-pick <commit-a> <commit-b>

Cherry-pick perubahan tanpa langsung commit

git cherry-pick --no-commit <commit-id>

Jika terjadi conflict

Selesaikan conflict kemudian:

git add .
git cherry-pick --continue

Batalkan cherry-pick

git cherry-pick --abort

24. Commit Tidak Sengaja Dibuat di Branch yang Salah

Misalnya commit dibuat di main, padahal seharusnya berada di feature/login.

Cari hash:

git log --oneline -5

Misalnya commit:

abc1234 add login page

Pindah ke branch yang benar:

git switch feature/login

Ambil commit tersebut:

git cherry-pick abc1234

Kembali ke branch yang salah:

git switch main

Jika commit belum dipush:

git reset --hard HEAD~1

Jika sudah dipush dan branch digunakan bersama, biasanya lebih aman menggunakan:

git revert abc1234

25. Membersihkan File Untracked

Lihat apa yang akan dihapus terlebih dahulu

git clean -n

Untuk file dan directory:

git clean -nd

Hapus file untracked

git clean -f

Hapus file dan directory untracked

git clean -fd

Jalankan git clean -n terlebih dahulu. File untracked yang dihapus mungkin tidak bisa dipulihkan melalui Git karena belum pernah masuk repository.

26. Reset Local Branch Agar Sama Persis dengan Remote

Misalnya local main sudah kacau dan ingin dibuat sama persis dengan origin/main.

Pertama:

git fetch origin

Kemudian:

git reset --hard origin/main

Jika juga ingin membuang file untracked:

git clean -fd

Semua commit lokal yang tidak ada di origin/main akan tidak lagi direferensikan oleh branch tersebut. Gunakan git reflog jika ternyata perlu recovery.

27. Conflict Resolution

Cek file conflict:

git status

Setelah memperbaiki isi file:

git add <file>

Jika sedang merge:

git merge --continue

Jika sedang rebase:

git rebase --continue

Jika sedang cherry-pick:

git cherry-pick --continue

Batalkan merge:

git merge --abort

Batalkan rebase:

git rebase --abort

Batalkan cherry-pick:

git cherry-pick --abort

28. Tracking Branch dan Upstream

Melihat upstream branch

git branch -vv

Set upstream saat push pertama

git push -u origin <branch>

Mengatur upstream secara manual

git branch --set-upstream-to=origin/<branch>

Setelah upstream tersedia:

git pull
git push

biasanya sudah cukup.

29. Menghapus Remote Branch yang Sudah Tidak Ada

Setelah branch dihapus dari GitHub/GitLab, local Git terkadang masih menampilkannya.

Gunakan:

git fetch --prune

atau:

git remote prune origin

Cek kembali:

git branch -a

30. Tags

Membuat lightweight tag

git tag <tag-name>

Membuat annotated tag

git tag -a <tag-name> -m "Pesan tag"

Contoh:

git tag -a v1.0.0 -m "Release v1.0.0"

Melihat tag

git tag

Push satu tag

git push origin <tag-name>

Push semua tag

git push origin --tags

Menghapus tag lokal

git tag -d <tag-name>

Menghapus tag remote

git push origin --delete <tag-name>

31. Melihat Commit Lama Tanpa Mengubah Branch

Gunakan detached HEAD:

git switch --detach <commit-id>

Contoh:

git switch --detach HEAD~3

Jika ternyata ingin melanjutkan pekerjaan dari sana:

git switch -c <nama-branch>

Jika hanya ingin kembali:

git switch -

32. Git Bisect untuk Mencari Commit Penyebab Bug

Jika aplikasi sebelumnya berjalan tetapi sekarang error dan tidak tahu commit mana penyebabnya, gunakan binary search dengan Git Bisect.

Mulai:

git bisect start

Tandai commit saat ini sebagai buruk:

git bisect bad

Tentukan commit lama yang diketahui masih bekerja:

git bisect good <commit-id>

Git akan checkout commit di tengah-tengah history.

Test aplikasi, kemudian tandai:

git bisect good

atau:

git bisect bad

Ulangi sampai Git menemukan commit pertama yang menyebabkan masalah.

Setelah selesai:

git bisect reset

33. Alias

Alias memperpendek command yang sering digunakan.

Alias status

git config --global alias.st status

Sehingga:

git st

Alias commit

git config --global alias.ci commit

Alias checkout

git config --global alias.co checkout

Alias branch

git config --global alias.br branch

Alias log yang lebih nyaman

git config --global alias.lg "log --oneline --graph --decorate --all"

Kemudian:

git lg

34. Command Recovery yang Sebaiknya Dihafal

Beberapa command berikut sangat berguna ketika terjadi kesalahan:

git status

Melihat keadaan repository.

git log --oneline --graph --decorate --all

Memahami history.

git reflog

Mencari commit/HEAD yang sebelumnya masih ada.

git restore --staged <file>

Mengeluarkan file dari staging tanpa menghapus perubahan.

git reset --soft HEAD~1

Membatalkan commit terakhir tetapi mempertahankan perubahan di staging.

git reset HEAD~1

Membatalkan commit terakhir tetapi mempertahankan perubahan sebagai unstaged.

git revert <commit-id>

Membalik commit tanpa rewrite history.

git rebase --abort

Keluar dari rebase bermasalah.

git merge --abort

Keluar dari merge bermasalah.

git cherry-pick --abort

Keluar dari cherry-pick bermasalah.

35. Quick Reference: “Saya Ingin…”

Tujuan	Command
Batalkan commit terakhir, perubahan tetap staged	`git reset --soft HEAD~1`
Batalkan commit terakhir, perubahan tetap ada tetapi unstaged	`git reset HEAD~1`
Hapus commit terakhir beserta perubahannya	`git reset --hard HEAD~1`
Batalkan commit yang sudah dipush tanpa rewrite history	`git revert <commit>`
Hapus commit tertentu dari history	`git rebase -i <commit>^` lalu `drop`
Recovery commit yang tidak sengaja hilang	`git reflog`
Ubah commit terakhir	`git commit --amend`
Tambahkan file ke commit terakhir tanpa ubah pesan	`git add <file> && git commit --amend --no-edit`
Unstage file	`git restore --staged <file>`
Buang perubahan file	`git restore <file>`
Simpan perubahan sementara	`git stash`
Stash termasuk untracked file	`git stash -u`
Ambil stash dan hapus dari daftar	`git stash pop`
Ambil commit dari branch lain	`git cherry-pick <commit>`
Hapus local branch	`git branch -d <branch>`
Paksa hapus local branch	`git branch -D <branch>`
Hapus remote branch	`git push origin --delete <branch>`
Bersihkan stale remote branches	`git fetch --prune`
Lihat graph seluruh branch	`git log --oneline --graph --decorate --all`
Reset local branch sama persis seperti remote	`git fetch && git reset --hard origin/<branch>`
Push setelah rewrite history	`git push --force-with-lease`
Cek file untracked yang akan dihapus	`git clean -n`
Hapus file/directory untracked	`git clean -fd`
Pindah ke branch sebelumnya	`git switch -`

36. Perbedaan `reset`, `restore`, `revert`, dan `rebase`

`git restore`

Digunakan terutama untuk file dan staging area.

git restore <file>
git restore --staged <file>

`git reset`

Digunakan untuk memindahkan HEAD dan/atau mengubah staging/working tree.

git reset --soft HEAD~1
git reset HEAD~1
git reset --hard HEAD~1

`git revert`

Membuat commit baru yang membalik perubahan commit sebelumnya.

git revert <commit>

Biasanya pilihan paling aman untuk commit yang sudah dipublish.

`git rebase`

Menulis ulang rangkaian commit.

git rebase -i HEAD~5

Berguna untuk:

Menghapus commit.
Mengubah commit lama.
Mengubah pesan commit.
Mengurutkan commit.
Squash beberapa commit.
Membersihkan history sebelum pull request.

Karena rebase mengubah commit hash, hindari melakukan rebase pada shared history tanpa koordinasi.

Git sangat sulit benar-benar “menghilangkan” data secara tidak sengaja karena banyak operasi masih dapat dipulihkan melalui reflog. Namun, command seperti git clean, reset --hard, history rewrite, dan force push tetap harus digunakan dengan hati-hati.

Jika ragu sebelum operasi destruktif, gunakan:

git status
git log --oneline --graph --decorate --all
git branch backup-before-rewrite

Baru setelah itu lakukan operasi yang diperlukan.

37. Mencari Commit Berdasarkan Query

Sebelum menghapus sesuatu dari history, cari dahulu commit yang terpengaruh.

Cari semua commit yang pernah mengubah `.env`

git log --all --oneline -- .env

Untuk melihat patch/perubahannya:

git log --all -p -- .env

Atau tampilkan nama file:

git log --all --name-status -- .env

Contoh output:

a31bc92 add environment config
912fd21 update database credentials
7d1aa42 fix production env

Kemudian inspect commit tertentu:

git show a31bc92

38. Mencari Commit Berdasarkan Isi Perubahan

Kadang yang dicari bukan nama file, tetapi suatu string di dalam perubahan Git.

Misalnya ingin mencari perubahan yang mengandung:

.env

Gunakan:

git log --all -G'\.env' --oneline

Untuk melihat patch:

git log --all -G'\.env' -p

-G mencari added/deleted lines yang cocok dengan regular expression.

Contoh lain:

git log --all -G'API_KEY' --oneline

git log --all -G'password' --oneline

git log --all -G'DATABASE_URL' --oneline

Cari berdasarkan string dengan `-S`

git log --all -S'.env' --oneline

Dengan patch:

git log --all -S'.env' -p

Perbedaannya:

-G<regex>   = cari baris diff yang cocok regex
-S<string>  = cari commit yang mengubah jumlah kemunculan string

Untuk pencarian umum pada perubahan, biasanya -G lebih intuitif.

39. Mencari Commit Berdasarkan Pesan Commit

Jika query berada di commit message:

git log --all --grep='.env' --oneline

Contoh:

git log --all --grep='hotfix' --oneline

git log --all --grep='database' --oneline

git log --all --grep='secret' --oneline

Ini hanya mencari commit message, bukan isi file atau diff.

40. Menghapus Satu Commit yang Ditemukan Berdasarkan Query

Misalnya:

git log --all --oneline -- .env

menghasilkan:

a31bc92 add .env
c912a88 update config
819ab21 initial project

Jika commit:

a31bc92

hanya berisi perubahan yang memang ingin dibuang seluruhnya, gunakan interactive rebase:

git rebase -i a31bc92^

Akan muncul:

pick a31bc92 add .env
pick ...
pick ...

Ubah menjadi:

drop a31bc92 add .env
pick ...
pick ...

Simpan editor.

Commit tersebut akan dihapus dari history branch.

Jika commit berada di root history

Gunakan:

git rebase -i --root

Kemudian ubah commit target menjadi:

drop

Jangan gunakan drop jika commit tersebut juga berisi perubahan penting pada file lain.

41. Menghapus Hanya Perubahan `.env` dari Satu Commit

Ini biasanya lebih aman daripada menghapus seluruh commit.

Misalnya commit:

a31bc92

mengubah:

.env
src/config.ts
README.md

Kita hanya ingin menghilangkan perubahan .env, tetapi mempertahankan src/config.ts dan README.md.

Mulai interactive rebase:

git rebase -i a31bc92^

Ubah:

pick a31bc92 ...

menjadi:

edit a31bc92 ...

Git akan berhenti pada commit tersebut.

Sekarang kembalikan .env ke kondisi sebelum commit tersebut:

git restore \
  --source=HEAD^ \
  --staged \
  --worktree \
  -- .env

Cek hasilnya:

git status

git diff

git diff --cached

Kemudian amend commit:

git commit --amend --no-edit

Lanjutkan rebase:

git rebase --continue

Hasilnya:

sebelum:

a31bc92
├── .env
├── src/config.ts
└── README.md

sesudah rewrite:

a31bc92'
├── src/config.ts
└── README.md

Perubahan .env hilang dari commit tersebut, tetapi perubahan file lain tetap ada.

42. Menghapus `.env` dari Seluruh Git History

Jika .env tidak seharusnya pernah masuk Git, cara yang lebih tepat adalah menghapus path tersebut dari seluruh history menggunakan git-filter-repo.

Sebelum melakukannya, sebaiknya gunakan fresh clone atau buat backup.

Hapus `.env` di root repository dari seluruh history

git filter-repo \
  --sensitive-data-removal \
  --invert-paths \
  --path .env

Ini menghapus .env dari seluruh rewritten history.

Misalnya sebelumnya:

A --- B --- C --- D
      |     |     |
    .env  .env  .env

Setelah filtering:

A' --- B' --- C' --- D'

Tidak ada versi .env pada rewritten history tersebut.

Perubahan file lain dalam commit tetap dipertahankan.

43. Menghapus Semua `.env` Termasuk yang Berada di Subdirectory

Repository kadang memiliki:

.env
backend/.env
frontend/.env
apps/api/.env

Gunakan:

git filter-repo \
  --sensitive-data-removal \
  --invert-paths \
  --path .env \
  --path-glob '*/.env'

--path digunakan untuk path exact, sedangkan --path-glob dapat digunakan untuk wildcard.

Setelah itu verifikasi:

git log --all -- .env

dan:

git log --all -- '*/.env'

44. Menghapus Semua File `.env*` dari History

Misalnya repository pernah memiliki:

.env
.env.local
.env.production
.env.development
backend/.env
backend/.env.production

Gunakan:

git filter-repo \
  --sensitive-data-removal \
  --invert-paths \
  --path-glob '.env*' \
  --path-glob '*/.env*'

Hati-hati: query .env* juga dapat cocok dengan file seperti .env.example.

Jika .env.example memang ingin dipertahankan, lebih aman sebutkan file sensitif secara eksplisit:

git filter-repo \
  --sensitive-data-removal \
  --invert-paths \
  --path .env \
  --path .env.local \
  --path .env.production \
  --path .env.development

45. Menghapus Berdasarkan Path Tertentu

Konsep yang sama dapat digunakan untuk file lain.

Hapus credentials

git filter-repo \
  --sensitive-data-removal \
  --invert-paths \
  --path config/credentials.json

Hapus private key

git filter-repo \
  --sensitive-data-removal \
  --invert-paths \
  --path private.pem

Hapus file database

git filter-repo \
  --invert-paths \
  --path database.sqlite

Hapus directory tertentu

git filter-repo \
  --invert-paths \
  --path storage/private/

46. Menghapus Isi Berdasarkan Query dari Seluruh History

Kadang file tidak ingin dihapus. Yang ingin dihapus hanya string tertentu.

Misalnya API key pernah masuk:

API_KEY=abc123-secret

Buat file:

replacements.txt

Isi:

abc123-secret

Kemudian:

git filter-repo \
  --sensitive-data-removal \
  --replace-text replacements.txt

Secara default string yang ditemukan akan diganti menjadi:

***REMOVED***

Tentukan replacement sendiri

Isi replacements.txt:

abc123-secret==>[REDACTED]

Kemudian:

git filter-repo \
  --sensitive-data-removal \
  --replace-text replacements.txt

47. Menghapus Literal String dari Seluruh History

Misalnya benar-benar ingin menghapus string:

.env

dari isi semua file sepanjang history.

Buat:

replacements.txt

Isi:

literal:.env==>

Kemudian:

git filter-repo --replace-text replacements.txt

Artinya:

.env

akan diganti dengan string kosong.

Ini sangat berbeda dengan menghapus file .env.

Command tersebut juga dapat mengubah:

README.md
.gitignore
docker-compose.yml
source code
documentation

jika file tersebut mengandung teks .env.

Jadi biasanya jangan gunakan ini untuk menghapus file .env.

Gunakan:

git filter-repo --invert-paths --path .env

jika tujuan sebenarnya adalah menghapus file .env dari history.

48. Query Menggunakan Regular Expression

git-filter-repo juga mendukung regex untuk replacement.

Contoh replacements.txt:

regex:API_KEY=[A-Za-z0-9_-]+==>API_KEY=[REMOVED]

Kemudian:

git filter-repo \
  --sensitive-data-removal \
  --replace-text replacements.txt

Contoh lain:

regex:password=.*==>password=[REMOVED]

Tetapi regex untuk secret harus dibuat dengan hati-hati agar tidak menghapus data legitimate.

49. Jangan Drop Semua Commit yang Menyentuh `.env`

Misalnya history:

A
|
B  add login + .env
|
C  add dashboard
|
D  update API + .env
|
E

Query:

git log --all --oneline -- .env

menghasilkan:

ddddddd update API + .env
bbbbbbb add login + .env

Secara teori Anda bisa menghapus:

B
D

tetapi itu juga akan menghapus:

login
API changes

jika perubahan tersebut berada dalam commit yang sama.

Jadi:

❌ cari commit .env
❌ drop semua commit tersebut

biasanya bukan solusi terbaik.

Lebih baik:

✅ git filter-repo --invert-paths --path .env

karena Git akan menghapus .env tetapi mempertahankan perubahan lain dalam commit.

50. Workflow Aman Menghapus `.env` dari History

1. Cari dahulu

git log --all --oneline -- .env

Kemudian:

git log --all -p -- .env

2. Backup

git branch backup-before-env-cleanup

Untuk cleanup besar, fresh clone lebih disarankan.

3. Jika hanya satu commit

git rebase -i <commit-id>^

Gunakan:

edit

lalu:

git restore \
  --source=HEAD^ \
  --staged \
  --worktree \
  -- .env

git commit --amend --no-edit
git rebase --continue

4. Jika seluruh history

git filter-repo \
  --sensitive-data-removal \
  --invert-paths \
  --path .env

5. Tambahkan `.env` ke `.gitignore`

.env
.env.local
.env.production
.env.development

Kemudian:

git add .gitignore
git commit -m "chore: ignore environment files"

Gunakan .env.example untuk template:

DATABASE_URL=
API_KEY=
APP_SECRET=

6. Verifikasi

git log --all --oneline -- .env

Seharusnya tidak menghasilkan commit terkait .env.

Cari juga berdasarkan patch:

git log --all -G'\.env' --oneline

Perlu diingat bahwa query kedua juga dapat menemukan referensi legitimate seperti .gitignore atau dokumentasi.

7. Jika history sebelumnya sudah berada di remote

History rewrite mengubah commit hash.

Push rewritten history sesuai workflow repository Anda.

Untuk rewrite satu branch:

git push --force-with-lease origin <branch>

Untuk proses sensitive-data cleanup seluruh repository, ikuti prosedur hosting provider karena branch, tag, pull request refs, clone collaborator, cache, dan fork juga dapat terpengaruh.

51. Jika `.env` Mengandung Secret

Jika .env pernah berisi:

API_KEY=...
DATABASE_PASSWORD=...
JWT_SECRET=...
PRIVATE_KEY=...

anggap secret tersebut sudah terekspos.

Urutan yang benar:

1. Revoke/rotate secret
2. Bersihkan Git history
3. Force-push rewritten history jika diperlukan
4. Bersihkan clone/copy lain
5. Tambahkan .env ke .gitignore
6. Gunakan .env.example tanpa secret

Menghapus .env dari Git history tidak membuat secret lama aman kembali.

Secret harus diganti.

52. Quick Reference — Search dan Delete Berdasarkan Query

Tujuan	Command
Cari commit yang mengubah `.env`	`git log --all --oneline -- .env`
Lihat patch `.env` sepanjang history	`git log --all -p -- .env`
Cari diff berisi `.env`	`git log --all -G'\.env' --oneline`
Cari perubahan jumlah string `.env`	`git log --all -S'.env' --oneline`
Cari commit message berisi `.env`	`git log --all --grep='.env' --oneline`
Inspect commit tertentu	`git show <commit-id>`
Hapus seluruh commit tertentu	`git rebase -i <commit>^` → `drop`
Edit commit tertentu	`git rebase -i <commit>^` → `edit`
Hapus hanya perubahan `.env` dari commit	`git restore --source=HEAD^ --staged --worktree -- .env` lalu amend
Hapus `.env` dari semua history	`git filter-repo --invert-paths --path .env`
Hapus nested `.env`	`git filter-repo --invert-paths --path .env --path-glob '*/.env'`
Hapus berbagai `.env*`	`git filter-repo --invert-paths --path-glob '.env' --path-glob '/.env*'`
Hapus path arbitrary dari history	`git filter-repo --invert-paths --path <path>`
Hapus/replace secret berdasarkan text	`git filter-repo --replace-text replacements.txt`
Cari query regex di diff	`git log -G'<regex>' --oneline`
Cari query string dengan pickaxe	`git log -S'<string>' --oneline`