Ada file yang sedang dilacak git, tetapi sekarang file tersebut ada dalam .gitignoredaftar.

Namun, file itu terus muncul git statussetelah diedit. Bagaimana Anda memaksa gituntuk sepenuhnya melupakannya?

.gitignoreakan mencegah file yang tidak terlacak ditambahkan (tanpa a add -f) ke set file yang dilacak oleh git, namun git akan terus melacak file apa pun yang sudah dilacak.

Untuk berhenti melacak file, Anda harus menghapusnya dari indeks. Ini dapat dicapai dengan perintah ini.

git rm --cached <file>

Jika Anda ingin menghapus seluruh folder, Anda harus menghapus semua file di dalamnya secara rekursif.

git rm -r --cached <folder>

Penghapusan file dari revisi kepala akan terjadi pada komit berikutnya.

PERINGATAN: Meskipun ini tidak akan menghapus file fisik dari lokal Anda, itu akan menghapus file dari mesin pengembang lain di selanjutnya git pull.

Serangkaian perintah di bawah ini akan menghapus semua item dari Git Index (bukan dari direktori kerja atau repo lokal), dan kemudian memperbarui Git Index, sementara menghormati git mengabaikan. PS. Indeks = Cache

Pertama:

git rm -r --cached . 
git add .

Kemudian:

git commit -am "Remove ignored files"

Atau satu-liner:

git rm -r --cached . && git add . && git commit -am "Remove ignored files"

git update-index melakukan pekerjaan untuk saya:

git update-index --assume-unchanged <file>

Catatan: Solusi ini sebenarnya independen .gitignorekarena gitignore hanya untuk file yang tidak dilacak.

sunting: Karena jawaban ini diposting, sebuah opsi baru telah dibuat dan itu harus lebih disukai. Anda harus menggunakan --skip-worktreeyang untuk file yang dilacak dimodifikasi yang pengguna tidak ingin melakukan lagi dan menjaga --assume-unchangedkinerja untuk mencegah git memeriksa status file yang dilacak besar. Lihat https://stackoverflow.com/a/13631525/717372 untuk rincian lebih lanjut ...

git update-index --skip-worktree <file>

git ls-files --ignored --exclude-standard -z | xargs -0 git rm --cached
git commit -am "Remove ignored files"

Ini mengambil daftar file yang diabaikan dan menghapusnya dari indeks, kemudian melakukan perubahan.

Saya selalu menggunakan perintah ini untuk menghapus file-file yang tidak terlacak. Output satu baris, gaya Unix, bersih:

git ls-files --ignored --exclude-standard | sed 's/.*/"&"/' | xargs git rm -r --cached

Ini mencantumkan semua file yang Anda abaikan, ganti setiap baris keluaran dengan garis yang dikutip sebagai ganti untuk menangani jalur dengan spasi di dalamnya, dan meneruskan segalanya git rm -r --cacheduntuk menghapus jalur / file / direktori dari indeks.

pindahkan, komit, lalu pindahkan kembali. Ini telah bekerja untuk saya di masa lalu. Mungkin ada cara 'gittier' untuk mencapai ini.

Jika Anda tidak dapat git rmmelacak file karena orang lain mungkin membutuhkannya (peringatan, bahkan jika Anda git rm --cached , ketika orang lain mendapatkan perubahan ini, file mereka akan dihapus dalam sistem file mereka). Ini sering dilakukan karena menimpa file konfigurasi, kredensial otentikasi, dll. Silakan lihat https://gist.github.com/1423106 untuk mengetahui cara orang mengatasi masalah tersebut.

Untuk meringkas:

• Mintalah aplikasi Anda mencari file config-overide.ini yang diabaikan dan menggunakannya di file config.ini yang sudah ditentukan (atau secara bergantian, cari ~ / .config / myapp.ini, atau $ MYCONFIGFILE)
• Komit file config-sample.ini dan abaikan file config.ini, buat skrip atau salin file yang serupa jika perlu.
• Cobalah menggunakan gitattributes clean / smudge magic untuk menerapkan dan menghapus perubahan untuk Anda, misalnya mencoreng file konfigurasi sebagai checkout dari cabang alternatif dan membersihkan file konfigurasi sebagai checkout dari HEAD. Ini adalah hal yang rumit, saya tidak merekomendasikannya untuk pengguna pemula.
• Simpan file konfigurasi pada cabang deploy yang didedikasikan untuk itu yang tidak pernah digabungkan untuk dikuasai. Saat Anda ingin menggunakan / mengkompilasi / menguji Anda bergabung ke cabang itu dan mendapatkan file itu. Ini pada dasarnya adalah pendekatan noda / bersih kecuali menggunakan kebijakan penggabungan manusia dan modul ekstra-git.
• Anti-recommentation: Jangan menggunakan asumsi-tidak berubah, itu hanya akan berakhir dengan air mata (karena berbohong pada dirinya sendiri akan menyebabkan hal-hal buruk terjadi, seperti perubahan Anda hilang selamanya).

Gunakan ini saat:

1. Anda ingin membuka banyak file, atau

2. Anda memperbarui file gitignore Anda

Tautan sumber: http://www.codeblocq.com/2016/01/Untrack-files-already-added-to-git-repository-based-on-gitignore/

Katakanlah Anda telah menambahkan / mengkomit beberapa file ke repositori git Anda dan kemudian menambahkannya ke .gitignore Anda; file-file ini akan tetap ada di indeks repositori Anda. Artikel ini akan kita lihat bagaimana cara menghilangkannya.

Langkah 1: Komit semua perubahan Anda

Sebelum melanjutkan, pastikan semua perubahan Anda dilakukan, termasuk file .gitignore Anda.

Langkah 2: Hapus semuanya dari repositori

Untuk menghapus repo Anda, gunakan:

git rm -r --cached .

• rm adalah perintah hapus
• -r akan memungkinkan penghapusan rekursif
• –Cached hanya akan menghapus file dari indeks. File Anda akan tetap ada di sana.

The rmperintah bisa tak kenal ampun. Jika Anda ingin mencoba apa yang dilakukan sebelumnya, tambahkan -natau--dry-run tandai untuk menguji hal-hal.

Langkah 3: Tambahkan kembali semuanya

git add .

Langkah 4: Berkomitmen

git commit -m ".gitignore fix"

Repositori Anda bersih :)

Dorong perubahan ke kendali jarak jauh Anda untuk melihat perubahannya juga efektif di sana.

Saya menyelesaikan ini dengan menggunakan git filter-branch . Perintah persis yang saya gunakan diambil dari halaman manual:

PERINGATAN : ini akan menghapus file dari seluruh riwayat Anda

git filter-branch --index-filter 'git rm --cached --ignore-unmatch filename' HEAD

Perintah ini akan membuat ulang seluruh riwayat komit, mengeksekusi git rmsebelum komit masing-masing sehingga akan menyingkirkan file yang ditentukan. Jangan lupa untuk mencadangkannya sebelum menjalankan perintah karena akan hilang.

Apa yang tidak berhasil untuk saya

(Di Linux), saya ingin menggunakan posting di sini yang menyarankan ls-files --ignored --exclude-standard | xargs git rm -r --cachedpendekatan. Namun, (beberapa) file yang akan dihapus memiliki baris baru / LF / \ndalam nama mereka. Tak satu pun dari solusi:

git ls-files --ignored --exclude-standard | xargs -d"\n" git rm --cached
git ls-files --ignored --exclude-standard | sed 's/.*/"&"/' | xargs git rm -r --cached

mengatasi situasi ini (dapatkan kesalahan tentang file tidak ditemukan).

Jadi saya menawarkan

git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached
git commit -am "Remove ignored files"

Ini menggunakan -zargumen untuk ls-file , dan -0argumen untuk xargs untuk melayani dengan aman / benar untuk karakter "jahat" dalam nama file.

Di halaman manual git-ls-files (1) , ia menyatakan:

Ketika opsi -z tidak digunakan, TAB, LF, dan karakter backslash di pathnames masing-masing direpresentasikan sebagai \ t, \ n, dan \\.

jadi saya pikir solusi saya diperlukan jika nama file memiliki karakter ini di dalamnya.

1. Perbarui .gitignorefile Anda - misalnya, tambahkan folder yang tidak ingin Anda lacak .gitignore.

2. git rm -r --cached .- Hapus semua file yang dilacak, termasuk yang diinginkan dan yang tidak diinginkan. Kode Anda akan aman selama Anda telah menyimpan secara lokal.

3. git add .- Semua file akan ditambahkan kembali, kecuali yang ada di .gitignore.

Kiat ujung ke @AkiraYamamoto karena mengarahkan kami ke arah yang benar.

Saya pikir, mungkin git tidak dapat sepenuhnya melupakan file karena konsepsinya ( bagian "Snapshots, Not Differences" ).

Masalah ini tidak ada, misalnya, saat menggunakan CVS. CVS menyimpan informasi sebagai daftar perubahan berbasis file. Informasi untuk CVS adalah seperangkat file dan perubahan yang dibuat untuk setiap file dari waktu ke waktu.

Tetapi di Git setiap kali Anda berkomitmen, atau menyimpan keadaan proyek Anda, pada dasarnya mengambil gambar apa semua file Anda pada saat itu dan menyimpan referensi ke snapshot itu. Jadi, jika Anda menambahkan file sekali, itu akan selalu ada di snapshot itu.

2 artikel ini sangat membantu saya:

git menganggap-tidak berubah vs melewatkan-worktree dan Cara mengabaikan perubahan dalam file yang dilacak dengan Git

Mendasarkan pada itu saya melakukan hal berikut, jika file sudah dilacak:

git update-index --skip-worktree <file>

Mulai saat ini semua perubahan lokal dalam file ini akan diabaikan dan tidak akan pergi ke remote. Jika file diubah di remote, konflik akan muncul, kapan git pull. Stash tidak akan berfungsi. Untuk mengatasinya, salin konten file ke tempat yang aman dan ikuti langkah-langkah ini:

git update-index --no-skip-worktree <file>
git stash
git pull 

Konten file akan diganti oleh konten jarak jauh. Rekatkan perubahan Anda dari tempat yang aman ke file dan lakukan lagi:

git update-index --skip-worktree <file>

Jika semua orang, yang bekerja dengan proyek, akan melakukan git update-index --skip-worktree <file>, masalah denganpull harus tidak ada. Solusi ini OK untuk file konfigurasi, ketika setiap pengembang memiliki konfigurasi proyek sendiri.

Sangat tidak nyaman untuk melakukan ini setiap kali, ketika file telah diubah pada remote, tetapi dapat melindunginya dari menimpa dengan konten jarak jauh.

Lakukan langkah-langkah berikut secara seri, Anda akan baik-baik saja.

1. menghapus file yang salah ditambahkan dari direktori / penyimpanan . Anda dapat menggunakan perintah "rm -r" (untuk linux) atau menghapusnya dengan menjelajahi direktori. Atau pindahkan ke lokasi lain di PC Anda. [Anda mungkin harus menutup IDE jika dijalankan untuk memindahkan / menghapus ]

2. Tambahkan file / direktori ke gitignorefile sekarang dan simpan.

3.Sekarang menghapusnya dari cache git dengan menggunakan perintah ini (jika ada lebih dari satu direktori, hapus satu per satu dengan berulang kali mengeluarkan perintah ini)

git rm -r --cached path-to-those-files

4.Now melakukan suatu komit dan dorongan , menggunakan perintah ini. Ini akan menghapus file-file itu dari git remote dan membuat git berhenti melacak file-file itu.

git add .
git commit -m "removed unnecessary files from git"
git push origin

Jawaban salin / tempel adalah git rm --cached -r .; git add .; git status

Perintah ini akan mengabaikan file yang telah dikomit ke repositori Git tetapi sekarang kami telah menambahkannya ke .gitignore.

Jawaban dari Matt Fear adalah IMHO paling efektif. Berikut ini hanyalah skrip PowerShell bagi mereka yang berada di windows untuk hanya menghapus file dari repo git mereka yang cocok dengan daftar pengecualian mereka.

# Get files matching exclusionsfrom .gitignore
# Excluding comments and empty lines
$ignoreFiles =  gc .gitignore | ?{$_ -notmatch  "#"} |  ?{$_ -match  "\S"} | % {
                    $ignore = "*" + $_ + "*"
                    (gci -r -i $ignore).FullName
                }
$ignoreFiles = $ignoreFiles| ?{$_ -match  "\S"}

# Remove each of these file from Git 
$ignoreFiles | % { git rm $_}

git add .

Pindahkan atau salin file ke lokasi yang aman, sehingga Anda tidak kehilangannya. Kemudian git file dan komit. File masih akan muncul jika Anda kembali ke salah satu dari komit sebelumnya, atau cabang lain di mana itu belum dihapus. Namun, di semua komitmen di masa mendatang, Anda tidak akan melihat file lagi. Jika file di git diabaikan, maka Anda dapat memindahkannya kembali ke folder, dan git tidak akan melihatnya.

Menggunakan git rm --cachedperintah tidak menjawab pertanyaan awal:

Bagaimana Anda memaksa gituntuk sepenuhnya melupakan [file]?

Bahkan, solusi ini akan menyebabkan file dihapus di setiap instance repositori lainnya ketika menjalankan git pull!

Cara yang benar untuk memaksa git melupakan file didokumentasikan oleh GitHub di sini .

Saya merekomendasikan membaca dokumentasi, tetapi pada dasarnya:

git fetch --all
git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch full/path/to/file' --prune-empty --tag-name-filter cat -- --all
git push origin --force --all
git push origin --force --tags
git for-each-ref --format='delete %(refname)' refs/original | git update-ref --stdin
git reflog expire --expire=now --all
git gc --prune=now

ganti saja full/path/to/filedengan path lengkap file. Pastikan Anda telah menambahkan file ke file Anda .gitignore.

Anda juga perlu (sementara) mengizinkan push-push tidak-maju ke repositori Anda , karena Anda mengubah riwayat git Anda.

The BFG dirancang khusus untuk menghapus data yang tidak diinginkan seperti file besar atau password dari repo Git, sehingga memiliki bendera sederhana yang akan menghapus setiap sejarah besar (tidak-di-saat-komit) file: '--strip-blobs- lebih besar dari'

$ java -jar bfg.jar --strip-blobs-bigger-than 100M

Jika Anda ingin menentukan file dengan nama, Anda dapat melakukannya juga:

$ java -jar bfg.jar --delete-files *.mp4

BFG 10-1000x lebih cepat dari git-cabang filter, dan umumnya lebih mudah digunakan - lihat petunjuk penggunaan lengkap dan contoh untuk detail lebih lanjut.

Sumber: https://confluence.atlassian.com/bitbucket/reduce-repository-size-321848262.html

Jika Anda tidak ingin menggunakan CLI dan bekerja di Windows, solusi yang sangat sederhana adalah dengan menggunakan TortoiseGit , ia memiliki Tindakan "Hapus (tetap lokal)" di menu yang berfungsi dengan baik.

Saya menyukai jawaban JonBrave tetapi saya memiliki cukup banyak direktori kerja yang komit yang membuat saya sedikit takut, jadi inilah yang saya lakukan:

git config --global alias.exclude-ignored '! git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached && git ls-files -z --ignored --exclude-standard | xargs -0 git stage && git stage .gitignore && git commit -m "gitignore baru dan hapus file yang diabaikan dari indeks" '

memecahnya:

git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached 
git ls-files -z --ignored --exclude-standard | xargs -0 git stage 
git stage .gitignore 
git commit -m "new gitignore and remove ignored files from index"

• hapus file yang diabaikan dari indeks
• tahap .gitignore dan file yang baru saja Anda hapus
• melakukan

Ini bukan lagi masalah di git terbaru (v2.17.1 pada saat penulisan).

Yang .gitignoreterakhir mengabaikan file yang dilacak tetapi dihapus. Anda dapat menguji ini sendiri dengan menjalankan skrip berikut. git statusPernyataan akhir harus melaporkan "tidak ada komitmen".

# Create empty repo
mkdir gitignore-test
cd gitignore-test
git init

# Create a file and commit it
echo "hello" > file
git add file
git commit -m initial

# Add the file to gitignore and commit
echo "file" > .gitignore
git add .gitignore
git commit -m gitignore

# Remove the file and commit
git rm file
git commit -m "removed file"

# Reintroduce the file and check status.
# .gitignore is now respected - status reports "nothing to commit".
echo "hello" > file
git status

Dalam hal sudah berkomitmen DS_Store:

find . -name .DS_Store -print0 | xargs -0 git rm --ignore-unmatch

Abaikan mereka dengan:

echo ".DS_Store" >> ~/.gitignore_global
echo "._.DS_Store" >> ~/.gitignore_global
echo "**/.DS_Store" >> ~/.gitignore_global
echo "**/._.DS_Store" >> ~/.gitignore_global
git config --global core.excludesfile ~/.gitignore_global

Akhirnya, buatlah komitmen!

Khusus untuk file berbasis IDE, saya menggunakan ini:

Misalnya slnx.sqlite, saya baru saja menghapusnya sepenuhnya seperti berikut:

git rm {PATH_OF_THE_FILE}/slnx.sqlite -f
git commit -m "remove slnx.sqlite"

Perlu diingat bahwa beberapa file tersebut menyimpan beberapa pengaturan pengguna lokal dan preferensi untuk proyek (seperti file apa yang Anda buka). Jadi setiap kali Anda menavigasi atau melakukan beberapa perubahan pada IDE Anda, file itu diubah dan karenanya memeriksa dan ditampilkan karena ada perubahan yang tidak dikomit.

Jawaban yang diterima tidak "membuat Git " lupa " tentang file ..." (secara historis). Itu hanya membuat git diabaikan file di masa sekarang / masa depan.

Metode ini membuat git benar-benar lupa file yang diabaikan ( dulu / sekarang / masa depan), tetapi tidak menghapus apa pun dari direktori kerja (bahkan ketika ditarik kembali dari jarak jauh).

Metode ini membutuhkan penggunaan /.git/info/exclude(lebih disukai) ATAU yang sudah ada .gitignore di semua komit yang memiliki file untuk diabaikan / dilupakan. ¹

Semua metode penegakan git mengabaikan perilaku setelah-fakta-secara efektif menulis ulang sejarah dan dengan demikian memiliki konsekuensi yang signifikan untuk setiap repositori publik / bersama / kolaboratif yang mungkin ditarik setelah proses ini. ²

Saran umum: mulai dengan repo bersih - semua yang dilakukan, tidak ada yang tertunda di direktori atau indeks kerja, dan buat cadangan !

Juga, komentar / riwayat revisi dari jawaban ini ( dan riwayat revisi dari pertanyaan ini ) mungkin berguna / mencerahkan.

#commit up-to-date .gitignore (if not already existing)
#this command must be run on each branch

git add .gitignore
git commit -m "Create .gitignore"

#apply standard git ignore behavior only to current index, not working directory (--cached)
#if this command returns nothing, ensure /.git/info/exclude AND/OR .gitignore exist
#this command must be run on each branch

git ls-files -z --ignored --exclude-standard | xargs -0 git rm --cached

#Commit to prevent working directory data loss!
#this commit will be automatically deleted by the --prune-empty flag in the following command
#this command must be run on each branch

git commit -m "ignored index"

#Apply standard git ignore behavior RETROACTIVELY to all commits from all branches (--all)
#This step WILL delete ignored files from working directory UNLESS they have been dereferenced from the index by the commit above
#This step will also delete any "empty" commits.  If deliberate "empty" commits should be kept, remove --prune-empty and instead run git reset HEAD^ immediately after this command

git filter-branch --tree-filter 'git ls-files -z --ignored --exclude-standard | xargs -0 git rm -f --ignore-unmatch' --prune-empty --tag-name-filter cat -- --all

#List all still-existing files that are now ignored properly
#if this command returns nothing, it's time to restore from backup and start over
#this command must be run on each branch

git ls-files --other --ignored --exclude-standard

Terakhir, ikuti panduan GitHub lainnya ini (mulai dari langkah 6) yang mencakup peringatan / informasi penting tentang perintah di bawah ini .

git push origin --force --all
git push origin --force --tags
git for-each-ref --format="delete %(refname)" refs/original | git update-ref --stdin
git reflog expire --expire=now --all
git gc --prune=now

Pengembang lain yang menarik dari repo jarak jauh yang dimodifikasi sekarang harus membuat cadangan lalu:

#fetch modified remote

git fetch --all

#"Pull" changes WITHOUT deleting newly-ignored files from working directory
#This will overwrite local tracked files with remote - ensure any local modifications are backed-up/stashed

git reset FETCH_HEAD

Catatan kaki

¹ Karena /.git/info/excludedapat diterapkan pada semua commit historis menggunakan instruksi di atas, mungkin detail tentang memasukkan .gitignorefile ke dalam commit historis yang memerlukannya berada di luar cakupan jawaban ini. Saya ingin yang tepat .gitignoreberada di root commit, seolah-olah itu adalah hal pertama yang saya lakukan. Orang lain mungkin tidak peduli karena /.git/info/excludedapat mencapai hal yang sama di mana pun .gitignoreada dalam sejarah commit, dan jelas menulis ulang sejarah adalah subjek yang sangat sensitif, bahkan ketika menyadari konsekuensi .

FWIW, metode potensial dapat mencakup git rebaseatau git filter-branchyang menyalin eksternal .gitignore ke setiap komit, seperti jawaban untuk pertanyaan ini

² Menegakkan perilaku git abaikan setelah fakta dengan melakukan hasil dari git rm --cachedperintah mandiri dapat mengakibatkan penghapusan file yang baru-baru ini diabaikan di tarikan di masa depan dari remote yang didorong paksa. The --prune-emptybendera di berikut git filter-branchperintah menghindari masalah ini dengan secara otomatis menghapus sebelumnya "menghapus semua file diabaikan" Indeks hanya komit. Menulis ulang sejarah git juga mengubah hash, yang akan mendatangkan malapetaka di masa depan dari repositori publik / bersama / kolaboratif. Harap pahami konsekuensi sepenuhnya sebelum melakukan ini pada repo tersebut. Panduan GitHub ini menetapkan yang berikut:

Beri tahu kolaborator Anda untuk rebase , bukan menggabungkan, cabang apa pun yang mereka buat dari riwayat repositori Anda yang lama (ternoda). Satu komit gabungan dapat memperkenalkan kembali sebagian atau seluruh sejarah yang tercemar yang baru saja Anda susahkan untuk dibersihkan.

Solusi alternatif yang tidak memengaruhi repo jarak jauh adalah git update-index --assume-unchanged </path/file>atau git update-index --skip-worktree <file>, contohnya dapat ditemukan di sini .

Jika ada yang mengalami kesulitan di Windows dan Anda ingin mengabaikan seluruh folder, 'cd' untuk yang diinginkan 'folder' dan lakukan 'Git Bash Here'.

git ls-files -z | xargs -0 git update-index --assume-unchanged

Dalam kasus saya di sini, saya memiliki beberapa file .lock di beberapa direktori yang perlu saya hapus. Saya menjalankan yang berikut ini dan berhasil tanpa harus masuk ke setiap direktori untuk menghapusnya:

git rm -r --cached **/*.lock

Melakukan ini masuk ke setiap folder di bawah 'root' di mana saya berada dan mengecualikan semua file yang cocok dengan pola.

Semoga ini bisa membantu orang lain!