Gitignore untuk Pemula: 10 File yang Jangan Masuk Repo

Bayangkan kamu baru selesai membuat proyek pertamamu, lalu mengunggahnya ke GitHub dengan bangga. Beberapa menit kemudian kamu sadar: folder node_modules ratusan megabyte ikut terunggah, dan berkas .env berisi kata sandi basis data terlihat oleh siapa saja. Kejadian seperti ini sangat umum dialami pemula, dan penyebabnya sama: belum mengenal gitignore untuk pemula.

Berkas .gitignore memberi tahu Git file dan folder mana yang harus diabaikan. Artikel ini menjawab pertanyaan utamanya: file apa saja yang tidak perlu masuk repository Git, mengapa, bagaimana menuliskan aturannya, dan apa yang harus dilakukan jika file terlanjur ter-commit.

Gitignore untuk pemula: file yang tidak perlu masuk repository Git

Ringkasan cepat

.gitignore adalah daftar pola file yang tidak akan dilacak Git.
Yang sebaiknya diabaikan: dependensi, hasil build, rahasia, berkas editor dan sistem operasi, log, cache, dan berkas lokal.
.gitignore tidak berpengaruh pada file yang sudah terlanjur dilacak.
Rahasia yang sudah ter-commit harus dianggap bocor, dan perlu diganti.

Daftar Isi

Apa itu .gitignore dan mengapa penting
Cara kerja .gitignore
Membuat .gitignore pertamamu
Aturan penulisan pola
10 file yang tidak perlu masuk repository Git
File yang justru harus masuk
Contoh .gitignore per jenis proyek
Template siap pakai
Jika file terlanjur ter-commit
.gitignore global dan pengecualian lokal
Cara memeriksa aturanmu
Kesalahan umum pemula
Checklist sebelum push
Mitos seputar .gitignore
Pertanyaan yang sering diajukan

Apa Itu .gitignore dan Mengapa Penting?

Git, secara bawaan, memperhatikan semua file di folder proyekmu. Padahal tidak semuanya layak disimpan di repository Git. Ada file yang bisa dibuat ulang otomatis, ada yang bersifat pribadi, dan ada yang berbahaya jika terbuka untuk umum. Berkas .gitignore adalah teks biasa di folder proyek yang berisi daftar pola nama file atau folder yang akan diabaikan Git.

Mengapa memakai .gitignore itu penting?

Menjaga keamanan. Kata sandi, kunci API, dan sertifikat tidak ikut tersebar.
Menjaga repositori ringan. Folder dependensi dan hasil build bisa sangat besar dan memperlambat clone serta push.
Menghindari konflik. Berkas pengaturan editor dan cache yang berbeda tiap anggota tim bikin konflik tidak perlu.
Menjaga riwayat tetap bersih. Perubahan penting tidak tenggelam di antara ribuan berkas otomatis.
Mempermudah kolaborasi. Tim hanya membagikan berkas yang memang perlu.

Dokumentasi resminya dapat dibaca di halaman gitignore di git-scm.com.

Cara Kerja .gitignore

Untuk memahami .gitignore, bedakan dua kondisi file di Git:

Untracked: file baru yang belum pernah ditambahkan ke Git.
Tracked: file yang sudah masuk ke riwayat Git.

Aturan di .gitignore hanya berlaku untuk file untracked. Jika sebuah file sudah terlanjur dilacak, menambahkannya ke .gitignore tidak akan membuat Git berhenti melacaknya. Inilah sumber kebingungan terbesar pemula, dan akan dibahas lagi di bagian “Jika file terlanjur ter-commit”.

Membuat .gitignore Pertamamu

Buat berkas bernama .gitignore di folder utama proyek (satu folder dengan .git). Buat lewat editor kode atau terminal, karena beberapa pengelola berkas bisa menolak nama yang diawali titik.
Tulis satu pola per baris. Baris kosong diabaikan, dan baris yang diawali tanda pagar adalah komentar.
Simpan dan commit berkas .gitignore itu sendiri agar seluruh tim memakai aturan yang sama.

Contoh isi paling sederhana:

# Dependensi
node_modules/

# Rahasia
.env

# Log
*.log

Aturan Penulisan Pola di .gitignore

Pola	Artinya	Contoh
`nama.txt`	Mengabaikan file dengan nama itu di mana pun	`rahasia.txt`
`*.log`	Tanda bintang mewakili sembarang karakter (kecuali garis miring)	Semua file berakhiran .log
`folder/`	Garis miring di akhir berarti folder	`node_modules/`
`/build`	Garis miring di awal berarti hanya di folder utama	Hanya build di akar proyek
`**/temp`	Dua bintang berarti folder di kedalaman berapa pun	temp di semua subfolder
`!penting.log`	Tanda seru membatalkan aturan (pengecualian)	Tetap lacak penting.log
`file?.txt`	Tanda tanya mewakili satu karakter	file1.txt, fileA.txt
`*.py[cod]`	Kurung siku mewakili salah satu karakter di dalamnya	.pyc, .pyo, .pyd
`# komentar`	Baris catatan, tidak berfungsi sebagai aturan	Penjelasan

Dua hal penting: aturan di bawah mengalahkan aturan di atas jika bertabrakan, dan kamu tidak bisa mengecualikan file jika folder induknya sudah diabaikan sepenuhnya.

10 File yang Tidak Perlu Masuk Repository Git

Berikut sepuluh kelompok berkas yang hampir selalu sebaiknya diabaikan, lengkap dengan alasan dan contoh polanya.

1. Dependensi (node_modules, venv, vendor)

Folder berisi pustaka yang diunduh otomatis lewat pengelola paket. Ukurannya besar dan bisa dibuat ulang dari daftar dependensi seperti package.json atau requirements.txt.

node_modules/
.venv/
venv/
vendor/

2. Hasil build dan keluaran kompilasi

Berkas hasil kompilasi atau bundel bisa dihasilkan ulang dari kode sumber, sehingga menyimpannya hanya menambah konflik dan ukuran.

dist/
build/
target/
bin/
obj/
*.class

3. Rahasia dan kredensial

Ini yang paling penting. Berkas seperti .env, kunci pribadi, dan sertifikat tidak boleh masuk repository, apalagi yang bersifat publik.

.env
.env.*
!.env.example
*.pem
*.key

4. Pengaturan editor dan IDE

Preferensi pribadi tiap pengembang tidak perlu dibagikan, dan bisa memicu konflik di tim.

.idea/
.vscode/
*.swp

5. Berkas bawaan sistem operasi

Dibuat otomatis oleh sistem dan tidak ada hubungannya dengan proyek.

.DS_Store
Thumbs.db
Desktop.ini

6. Log dan berkas sementara

Catatan kejadian dan berkas sementara selalu berubah dan tidak berguna bagi orang lain.

*.log
npm-debug.log*
*.tmp
*.bak

7. Cache

Data hasil optimasi yang dibuat otomatis oleh alat dan bahasa pemrograman.

.cache/
__pycache__/
.pytest_cache/

8. Hasil pengujian dan laporan cakupan

Laporan yang dibuat ulang setiap kali tes dijalankan.

coverage/
.nyc_output/
htmlcov/

9. Berkas besar, media, dan data mentah

Git dirancang untuk teks, bukan berkas besar. Unduhan data, rekaman, dan arsip besar sebaiknya disimpan di tempat lain. Jika berkas besar memang harus dilacak, pertimbangkan alat seperti Git LFS.

*.zip
*.mp4
data/raw/

10. Berkas lokal dan basis data pribadi

Pengaturan khusus mesinmu dan basis data lokal untuk pengembangan tidak perlu dibagikan, dan bisa berisi data sensitif.

*.sqlite3
local.properties
*.local

Daftar jenis file yang sebaiknya diabaikan Git

File yang Justru Harus Masuk Repository Git

Jangan terlalu bersemangat mengabaikan. Beberapa berkas memang harus ikut dilacak:

Berkas	Mengapa perlu dilacak
`.gitignore` itu sendiri	Agar semua anggota tim memakai aturan yang sama
Berkas kunci dependensi (`package-lock.json`, `yarn.lock`, `poetry.lock`)	Menjamin semua orang memakai versi pustaka yang sama
`.env.example`	Contoh nama variabel tanpa nilai rahasia, sebagai panduan anggota baru
Kode sumber dan aset proyek	Inti dari repositori
README dan dokumentasi	Membantu orang memahami dan menjalankan proyek
Konfigurasi yang dibagikan (misalnya `.editorconfig`)	Menyeragamkan gaya penulisan kode

Aturan umum: jika sebuah berkas bisa dibuat ulang otomatis atau bersifat pribadi, abaikan. Jika berkas itu dibutuhkan orang lain untuk menjalankan proyek, lacak.

Contoh .gitignore per Jenis Proyek

Proyek Node.js atau React

# Dependensi
node_modules/Hasil build
dist/
build/
Variabel lingkungan dan rahasia
.env
.env.*
!.env.example
Log
.log
npm-debug.log
Cache dan pengujian
.cache/
coverage/
Editor dan sistem operasi
.vscode/
.idea/
.DS_Store
Thumbs.db

Proyek Python

# Cache dan hasil kompilasi
__pycache__/
*.py[cod]Lingkungan virtual
.venv/
venv/
Rahasia
.env
Hasil paket dan build
*.egg-info/
dist/
build/
Pengujian
.pytest_cache/
htmlcov/
Editor dan sistem operasi
.vscode/
.idea/
.DS_Store

Gambaran jenis proyek lain

Jenis proyek	Yang biasanya diabaikan
Java (Maven atau Gradle)	`target/`, `build/`, `.gradle/`, `*.class`
PHP (Composer)	`vendor/`, `.env`
.NET	`bin/`, `obj/`, `*.user`
Flutter dan Android	`build/`, `.dart_tool/`, `local.properties`, `*.jks`
Terraform	`.terraform/`, `*.tfstate` (berkas state bisa berisi data sensitif)

Daftar di atas gambaran umum. Struktur proyekmu bisa berbeda, jadi sesuaikan dengan folder yang benar-benar ada.

Template .gitignore Siap Pakai

Kamu tidak perlu menulis semuanya dari nol. Ada kumpulan template resmi dan generator:

Repositori github/gitignore: kumpulan template untuk berbagai bahasa dan kerangka kerja yang dikelola komunitas.
gitignore.io (Toptal): generator yang menggabungkan template beberapa bahasa, editor, dan sistem operasi sekaligus.

Template adalah titik awal. Baca isinya dan sesuaikan, jangan menempelnya mentah-mentah, supaya kamu paham alasan tiap barisnya. Panduan Git yang lebih luas ada di buku Pro Git.

Jika File Terlanjur Ter-commit

Ini situasi yang paling sering membuat pemula panik. Ada dua hal berbeda yang perlu ditangani.

1. Menghentikan pelacakan file biasa

Jika file atau folder sudah dilacak tetapi seharusnya diabaikan (misalnya node_modules), tambahkan aturannya ke .gitignore, lalu hapus dari pelacakan tanpa menghapus file dari komputermu:

git rm -r --cached node_modules
git commit -m "Berhenti melacak node_modules"

Opsi --cached penting: ia hanya mencabut file dari pelacakan Git, sedangkan file aslinya tetap ada di komputermu. Untuk satu berkas, cukup git rm --cached nama-file.

2. Rahasia yang terlanjur ter-commit

Ini lebih serius. Menambahkan .env ke .gitignore setelah ter-commit tidak menghapusnya dari riwayat. Siapa pun yang punya akses ke riwayat repositori masih bisa melihat isinya.

Anggap rahasia itu sudah bocor, terutama jika repositorinya publik atau pernah diunggah.
Segera ganti atau cabut kredensialnya: buat kata sandi atau kunci API baru dan nonaktifkan yang lama.
Hentikan pelacakan berkasnya dengan langkah di atas dan pastikan .gitignore sudah benar.
Bersihkan riwayat jika perlu memakai alat khusus untuk menulis ulang riwayat. Ini langkah lanjutan dan berisiko pada repositori bersama, jadi pelajari dokumentasinya dengan teliti.
Aktifkan perlindungan pemindaian rahasia jika layanan hosting repositorimu menyediakannya.

Urutan terpenting: mengganti kredensial lebih utama daripada membersihkan riwayat, karena menghapus riwayat tidak menjamin tidak ada yang sudah menyalinnya.

.gitignore Global dan Pengecualian Lokal

Ada tiga tempat untuk menuliskan aturan abaikan, dengan cakupan berbeda:

Lokasi	Cakupan	Cocok untuk
`.gitignore` di repositori	Dibagikan ke semua orang yang memakai repositori	Aturan proyek: dependensi, build, rahasia
`.git/info/exclude`	Hanya di repositori ini di komputermu, tidak dibagikan	Berkas pribadi khusus proyek ini
Berkas global di komputermu	Berlaku untuk semua repositori di komputermu	Berkas sistem operasi dan editor

Untuk membuat berkas global, tentukan lokasinya dengan konfigurasi Git:

git config --global core.excludesFile ~/.gitignore_global

Lalu isi berkas itu dengan pola seperti .DS_Store atau .idea/. Dengan begitu kamu tidak perlu mengulang aturan yang sama di setiap proyek. Bagi proyek bersama, tetap sertakan aturan penting di .gitignore repositori, karena anggota lain belum tentu punya berkas global yang sama.

Cara Memeriksa Aturan .gitignore-mu

git status
git status --ignored
git check-ignore -v .env
git add -n .

git status menampilkan file yang akan dilacak. Pastikan tidak ada berkas rahasia atau besar di daftar itu.
git status --ignored menampilkan file yang sedang diabaikan.
git check-ignore -v nama-file menjelaskan aturan mana yang membuat sebuah file diabaikan, atau tidak menampilkan apa-apa jika tidak diabaikan.
git add -n . mensimulasikan penambahan tanpa benar-benar menambahkan, sehingga kamu bisa melihat apa yang akan masuk.

Biasakan menjalankan git status sebelum setiap commit pertama pada proyek baru. Dua menit pemeriksaan bisa menghindarkan kebocoran yang merepotkan. Baca juga perbedaan Git merge dan rebase untuk melanjutkan belajar Git.

Kesalahan Umum Pemula pada .gitignore

Menambah aturan setelah file ter-commit. Aturan tidak berlaku untuk file yang sudah dilacak.
Lupa me-commit .gitignore. Anggota tim lain tidak mendapat aturan yang sama.
Mengabaikan berkas kunci dependensi. Padahal itu menjamin versi yang konsisten.
Mengabaikan terlalu banyak. Misalnya mengabaikan seluruh folder src secara tidak sengaja.
Lupa garis miring di akhir folder, sehingga aturan tidak bekerja seperti yang diharapkan.
Menaruh komentar di baris yang sama dengan pola. Komentar harus berada di barisnya sendiri.
Menyalin template tanpa membaca. Sebagian aturan mungkin tidak sesuai proyekmu.
Mengira .gitignore melindungi dari kebocoran yang sudah terjadi. Ia hanya mencegah kejadian berikutnya.
Memasukkan kredensial langsung ke kode. Gunakan variabel lingkungan agar bisa diabaikan dengan benar.

Checklist Sebelum Push ke Repository Git

File .gitignore sudah dibuat dan di-commit.
Dependensi dan hasil build sudah diabaikan.
Berkas .env dan kredensial lain sudah diabaikan dan tidak ada di riwayat.
Ada .env.example sebagai panduan tanpa nilai rahasia.
git status sudah diperiksa dan tidak ada berkas aneh atau besar.
Berkas kunci dependensi ikut dilacak.
Berkas sistem operasi dan editor sudah diabaikan (di proyek atau global).
README menjelaskan cara menyiapkan proyek, termasuk variabel lingkungan yang dibutuhkan.

Jika proyekmu memakai Docker, ada berkas serupa bernama .dockerignore yang membantu menjaga image tetap ramping. Pelajari di panduan Docker container untuk pemula.

Mitos seputar .gitignore

“Menambahkan file ke .gitignore langsung menghapusnya dari Git.” Tidak. Ia hanya mencegah file baru dilacak.
“Repositori pribadi tidak perlu .gitignore.” Perlu. Repositori pribadi bisa menjadi publik, dan ukuran serta kerapihan tetap penting.
“Cukup hapus .env dari commit terbaru, beres.” Isi lama masih ada di riwayat.
“Satu .gitignore cocok untuk semua proyek.” Tiap jenis proyek punya berkas yang berbeda.
“Lebih banyak aturan berarti lebih aman.” Aturan berlebihan bisa membuat berkas penting tidak terlacak.
“Folder kosong akan tetap dilacak.” Git tidak melacak folder kosong. Banyak orang menaruh berkas penanda seperti .gitkeep untuk mengakalinya.

Untuk panduan ngoding lainnya, kunjungi NgodingDaily.

Pertanyaan yang Sering Diajukan

Apa itu .gitignore?

.gitignore adalah berkas teks berisi pola nama file dan folder yang diabaikan Git sehingga tidak ikut dilacak atau masuk ke repository.

File apa saja yang sebaiknya masuk .gitignore?

Dependensi, hasil build, berkas rahasia seperti .env, pengaturan editor dan sistem operasi, log, cache, hasil pengujian, berkas besar, dan berkas lokal pribadi.

Mengapa file saya masih muncul di git status padahal sudah masuk .gitignore?

Kemungkinan file itu sudah terlanjur dilacak. Hentikan pelacakannya dengan git rm –cached, lalu commit.

Apakah .gitignore harus di-commit?

Ya, agar seluruh anggota tim memakai aturan yang sama.

Bagaimana cara mengabaikan satu folder?

Tulis nama folder diikuti garis miring, misalnya node_modules/, di baris sendiri di .gitignore.

Apakah .env harus dimasukkan ke .gitignore?

Ya. Berkas .env biasanya berisi kata sandi dan kunci rahasia, sehingga tidak boleh masuk repository.

Apakah package-lock.json perlu diabaikan?

Umumnya tidak. Berkas kunci dependensi sebaiknya dilacak agar semua orang memakai versi pustaka yang sama.

Bagaimana jika kunci API terlanjur ter-commit?

Anggap sudah bocor. Segera ganti atau cabut kunci tersebut, lalu hentikan pelacakan berkasnya dan bersihkan riwayat bila perlu.

Bagaimana cara mengabaikan file di semua proyek sekaligus?

Gunakan berkas gitignore global lewat konfigurasi core.excludesFile, cocok untuk berkas sistem operasi dan editor.

Kesimpulan

Memahami gitignore untuk pemula adalah salah satu kebiasaan paling berharga sejak awal belajar Git. Abaikan dependensi, hasil build, rahasia, berkas editor dan sistem operasi, log, cache, hasil pengujian, berkas besar, dan berkas lokal, tetapi tetap lacak berkas kunci dependensi dan contoh konfigurasi. Ingat bahwa .gitignore hanya bekerja untuk file yang belum dilacak, dan rahasia yang terlanjur masuk repository Git harus segera diganti. Dengan satu berkas kecil dan pemeriksaan sederhana sebelum push, repositorimu menjadi lebih aman, ringan, dan rapi.