Hay un archivo que estaba siendo rastreado git, pero ahora el archivo está en la .gitignorelista.

Sin embargo, ese archivo sigue apareciendo git statusdespués de ser editado. ¿Cómo obligas gita olvidarte por completo?

.gitignoreevitará que se agreguen add -farchivos sin seguimiento (sin un ) al conjunto de archivos rastreados por git, sin embargo, git continuará rastreando cualquier archivo que ya se esté rastreando.

Para dejar de rastrear un archivo, debe eliminarlo del índice. Esto se puede lograr con este comando.

git rm --cached <file>

Si desea eliminar una carpeta completa, debe eliminar todos los archivos de forma recursiva.

git rm -r --cached <folder>

La eliminación del archivo de la revisión principal se realizará en la próxima confirmación.

ADVERTENCIA: Si bien esto no eliminará el archivo físico de su local, a continuación eliminará los archivos de otras máquinas de desarrolladores git pull.

La serie de comandos a continuación eliminará todos los elementos del Índice de Git (no del directorio de trabajo o del repositorio local), y luego actualizará el Índice de Git, respetando los ignorados de git. PD. Índice = caché

Primero:

git rm -r --cached . 
git add .

Entonces:

git commit -am "Remove ignored files"

O una línea:

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

git update-index hace el trabajo por mí:

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

Nota: Esta solución es realmente independiente .gitignoreya que gitignore es solo para archivos sin seguimiento.

editar: desde que se publicó esta respuesta, se ha creado una nueva opción que debería preferirse. Debe usar --skip-worktreecuál es para los archivos rastreados modificados que el usuario ya no desea confirmar y mantener el --assume-unchangedrendimiento para evitar que git verifique el estado de los archivos rastreados grandes. Consulte https://stackoverflow.com/a/13631525/717372 para obtener más detalles ...

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

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

Esto toma la lista de los archivos ignorados y los elimina del índice, luego confirma los cambios.

Siempre uso este comando para eliminar esos archivos sin seguimiento. Una línea, estilo Unix, salida limpia:

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

Enumera todos los archivos ignorados, reemplaza cada línea de salida con una línea entre comillas para manejar rutas con espacios en el interior y pasa todo git rm -r --cachedpara eliminar las rutas / archivos / directorios del índice.

muévelo, comprométete, luego muévelo nuevamente. Esto me ha funcionado en el pasado. Probablemente hay una forma más ingeniosa de lograr esto.

Si no puede git rmrastrear un archivo porque otras personas podrían necesitarlo (advertencia, incluso si usted git rm --cached , cuando otra persona recibe este cambio, sus archivos se eliminarán en su sistema de archivos). A menudo se realizan debido a anulaciones de archivos de configuración, credenciales de autenticación, etc. Consulte https://gist.github.com/1423106 para conocer las formas en que las personas han solucionado el problema.

Para resumir:

• Haga que su aplicación busque un archivo ignorado config-overide.ini y úselo sobre el archivo confirmado config.ini (o alternativamente, busque ~ / .config / myapp.ini o $ MYCONFIGFILE)
• Confirme el archivo config-sample.ini e ignore el archivo config.ini, haga que un script o similar copie el archivo según sea necesario si es necesario.
• Intente usar gitattributes clean / smudge magic para aplicar y eliminar los cambios por usted, por ejemplo, difumine el archivo de configuración como pago desde una rama alternativa y limpie el archivo de configuración como pago desde HEAD. Esto es algo complicado, no lo recomiendo para el usuario novato.
• Mantenga el archivo de configuración en una rama de implementación dedicada a él que nunca se fusiona con master. Cuando desee implementar / compilar / probar, combine esa rama y obtenga ese archivo. Este es esencialmente el enfoque de manchas / limpieza, excepto el uso de políticas de fusión humana y módulos extra-git.
• Anti-recomendación: no use asumir sin cambios, solo terminará en lágrimas (porque tener una mentira para sí mismo hará que sucedan cosas malas, como que su cambio se pierda para siempre).

Use esto cuando:

1. Desea rastrear muchos archivos, o

2. Actualizaste tu archivo gitignore

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

Digamos que ya ha agregado / comprometido algunos archivos a su repositorio git y luego los agrega a su .gitignore; estos archivos seguirán presentes en su índice de repositorio. En este artículo veremos cómo deshacerse de ellos.

Paso 1: compromete todos tus cambios

Antes de continuar, asegúrese de que todos sus cambios estén confirmados, incluido su archivo .gitignore.

Paso 2: eliminar todo del repositorio

Para borrar su repositorio, use:

git rm -r --cached .

• rm es el comando eliminar
• -r permitirá la eliminación recursiva
• –Cached solo eliminará archivos del índice. Tus archivos seguirán ahí.

El rmcomando puede ser implacable. Si desea probar lo que hace de antemano, agregue el indicador -no --dry-runpara probar las cosas.

Paso 3: vuelve a agregar todo

git add .

Paso 4: Comprometerse

git commit -m ".gitignore fix"

Tu repositorio está limpio :)

Empuje los cambios a su control remoto para ver los cambios efectivos allí también.

Lo logré usando git filter-branch . El comando exacto que utilicé fue tomado de la página del manual:

ADVERTENCIA : esto eliminará el archivo de todo tu historial

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

Este comando recreará todo el historial de confirmación, ejecutándose git rmantes de cada confirmación y, por lo tanto, eliminará el archivo especificado. No olvide hacer una copia de seguridad antes de ejecutar el comando, ya que se perderá.

Lo que no funcionó para mí

(En Linux), quería usar las publicaciones aquí que sugieren el ls-files --ignored --exclude-standard | xargs git rm -r --cachedenfoque. Sin embargo, (algunos de) los archivos a eliminar tenían una nueva línea / LF / incrustada \nen sus nombres. Ninguna de las soluciones:

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

hacer frente a esta situación (obtener errores sobre archivos no encontrados).

Entonces ofrezco

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

Esto utiliza el -zargumento para archivos ls y el -0argumento para xargs para atender de forma segura / correcta los caracteres "desagradables" en los nombres de archivo.

En la página del manual git-ls-files (1) , dice:

Cuando no se usa la opción -z, los caracteres TAB, LF y barra diagonal inversa en los nombres de ruta se representan como \ t, \ n y \\, respectivamente.

así que creo que mi solución es necesaria si los nombres de archivo tienen alguno de estos caracteres.

1. Actualice su .gitignorearchivo; por ejemplo, agregue una carpeta a la que no desea realizar un seguimiento .gitignore.

2. git rm -r --cached .- Eliminar todos los archivos rastreados, incluidos los deseados y no deseados. Su código estará seguro siempre que haya guardado localmente.

3. git add .- Todos los archivos se volverán a agregar, excepto los de .gitignore.

Felicitaciones a @AkiraYamamoto por señalarnos en la dirección correcta.

Creo que tal vez git no puede olvidarse por completo del archivo debido a su concepción ( sección "Instantáneas, no diferencias" ).

Este problema está ausente, por ejemplo, cuando se usa CVS. CVS almacena información como una lista de cambios basados ​​en archivos. La información para CVS es un conjunto de archivos y los cambios realizados en cada archivo a lo largo del tiempo.

Pero en Git cada vez que se compromete, o guarda el estado de su proyecto, básicamente toma una imagen de cómo se ven todos sus archivos en ese momento y almacena una referencia a esa instantánea. Entonces, si agregó el archivo una vez, siempre estará presente en esa instantánea.

Estos 2 artículos fueron útiles para mí:

git asumir-sin cambios vs skip-worktree y Cómo ignorar los cambios en los archivos rastreados con Git

Basándome en ello, hago lo siguiente, si el archivo ya está rastreado:

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

A partir de este momento, todos los cambios locales en este archivo serán ignorados y no irán a remoto. Si el archivo se cambia en remoto, ocurrirá un conflicto cuando git pull. Stash no funcionará. Para resolverlo, copie el contenido del archivo en el lugar seguro y siga estos pasos:

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

El contenido del archivo será reemplazado por el contenido remoto. Pegue sus cambios desde un lugar seguro a un archivo y realice nuevamente:

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

Si todos los que trabajan con el proyecto se desempeñarán git update-index --skip-worktree <file>, los problemas con pulldeberían estar ausentes. Esta solución está bien para archivos de configuración, cuando cada desarrollador tiene su propia configuración de proyecto.

No es muy conveniente hacer esto cada vez, cuando el archivo se ha cambiado en remoto, pero puede protegerlo de la sobrescritura de contenido remoto.

Realice los siguientes pasos en serie, estará bien.

1. elimine los archivos agregados por error del directorio / almacenamiento . Puede usar el comando "rm -r" (para linux) o eliminarlos explorando los directorios. O muévalos a otra ubicación en su PC. [Quizás necesite cerrar el IDE si está ejecutando para mover / quitar ]

2.agregue los archivos / directorios para gitignorearchivar ahora y guárdelo.

3.ahora elimínelos de la memoria caché de git utilizando estos comandos (si hay más de un directorio, elimínelos uno por uno emitiendo este comando repetidamente)

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

4.ahora haz un commit y push , usa estos comandos. Esto eliminará esos archivos de git remote y hará que git deje de rastrear esos archivos.

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

La respuesta copiar / pegar es git rm --cached -r .; git add .; git status

Este comando ignorará los archivos que ya se han confirmado en un repositorio de Git, pero ahora los hemos agregado .gitignore.

La respuesta de Matt Fear fue la más eficaz en mi humilde opinión. El siguiente es solo un script de PowerShell para aquellos en Windows para eliminar solo archivos de su repositorio de git que coincida con su lista de exclusión.

# 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 .

Mueva o copie el archivo a una ubicación segura, para que no lo pierda. Luego git rm el archivo y confirmar. El archivo seguirá apareciendo si vuelve a una de esas confirmaciones anteriores u otra rama donde no se ha eliminado. Sin embargo, en todas las confirmaciones futuras, no volverá a ver el archivo. Si el archivo está en git ignore, puede moverlo nuevamente a la carpeta y git no lo verá.

El uso del git rm --cachedcomando no responde la pregunta original:

¿Cómo obligas gita olvidarte por completo de [un archivo]?

De hecho, esta solución hará que el archivo se elimine en cualquier otra instancia del repositorio al ejecutar un git pull!

GitHub documenta aquí la forma correcta de forzar a git a olvidarse de un archivo .

Recomiendo leer la documentación, pero básicamente:

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

simplemente reemplácelo full/path/to/filecon la ruta completa del archivo. Asegúrate de haber agregado el archivo a tu .gitignore.

También necesitará (temporalmente) permitir empujes no rápidos hacia adelante a su repositorio , ya que está cambiando su historial de git.

El BFG está diseñado específicamente para eliminar datos no deseados como archivos grandes o contraseñas de repositorios Git, por lo que tiene un indicador simple que eliminará cualquier archivo histórico grande (no en su compromiso actual): '--strip-blobs- más grande que'

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

Si desea especificar los archivos por nombre, también puede hacerlo:

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

El BFG es 10-1000x más rápido que git filter-branch y, en general, es mucho más fácil de usar: consulte las instrucciones de uso completas y ejemplos para obtener más detalles.

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

Si no desea usar la CLI y está trabajando en Windows, una solución muy simple es usar TortoiseGit , tiene la acción "Eliminar (mantener local)" en el menú que funciona bien.

Me gustó la respuesta de JonBrave, pero tengo directorios de trabajo lo suficientemente desordenados que se comprometen -a me asusta un poco, así que esto es lo que he hecho:

git config --global alias.exclude-ignored '! git ls-files -z --no ignorado --exclude-standard | xargs -0 git rm -r - caché && git ls-files -z - ignorado --excluir-estándar | xargs -0 git stage && git stage .gitignore && git commit -m "nuevo gitignore y elimina los archivos ignorados del índice" '

desglosándolo:

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"

• eliminar archivos ignorados del índice
• stage .gitignore y los archivos que acaba de eliminar
• cometer

Esto ya no es un problema en el último git (v2.17.1 en el momento de la escritura).

El .gitignorefinalmente ignora los archivos rastreados pero eliminados. Puede probar esto usted mismo ejecutando el siguiente script. La git statusdeclaración final debe informar "nada que cometer".

# 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

En caso de ya comprometido DS_Store:

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

Ignóralos por:

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

Finalmente, ¡haz un compromiso!

Especialmente para los archivos basados ​​en IDE, uso esto:

Por ejemplo, slnx.sqlite, lo eliminé por completo como sigue:

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

Solo tenga en cuenta que algunos de esos archivos almacenan algunas configuraciones de usuario locales y preferencias para proyectos (como qué archivos tenía abiertos). Por lo tanto, cada vez que navega o hace algunos cambios en su IDE, ese archivo cambia y, por lo tanto, lo comprueba y muestra como hay cambios no confirmados.

La respuesta aceptada no "hace que Git " se olvide " de un archivo ..." (históricamente). Solo hace que git ignore el archivo en el presente / futuro.

Este método hace que git olvide por completo los archivos ignorados ( pasado / presente / futuro), pero no elimina nada del directorio de trabajo (incluso cuando se vuelve a extraer desde el control remoto).

Este método requiere el uso de /.git/info/exclude (preferido) O un preexistente .gitignore en todas las confirmaciones que tienen archivos que deben ignorarse / olvidarse. ¹

Todos los métodos para hacer cumplir git ignoran el comportamiento después de los hechos reescriben el historial de manera efectiva y, por lo tanto, tienen ramificaciones significativas para cualquier repositorio público / compartido / colaborativo que pueda retirarse después de este proceso. ²

Consejo general: comience con un repositorio limpio : todo está comprometido, nada pendiente en el directorio o índice de trabajo, ¡ y haga una copia de seguridad !

Además, el historial de comentarios / revisiones de esta respuesta ( y el historial de revisiones de de esta pregunta ) pueden ser útiles / esclarecedores.

#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

Finalmente, sigue el resto de esta guía de GitHub (comenzando en el paso 6) que incluye advertencias / información importante sobre los comandos a continuación .

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

Otros desarrolladores que extraen del repositorio remoto ahora modificado deben hacer una copia de seguridad y luego:

#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

Notas al pie

¹ Debido a que /.git/info/excludese puede aplicar a todas las confirmaciones históricas utilizando las instrucciones anteriores, quizás los detalles sobre cómo obtener un .gitignorearchivo en las confirmaciones históricas que lo necesitan están fuera del alcance de esta respuesta. Quería un apropiado .gitignorepara estar en el commit raíz, como si fuera lo primero que hiciera. Es posible que a otros no les importe, ya que /.git/info/excludepueden lograr lo mismo independientemente de dónde.gitignore exista en el historial de confirmaciones, y claramente reescribir el historial es un tema muy delicado, incluso cuando se tiene conocimiento de las ramificaciones .

FWIW, los métodos potenciales pueden incluir git rebaseo un git filter-branchque copia un externo .gitignore en cada confirmación, como las respuestas a esta pregunta

² Hacer cumplir el comportamiento de git ignore después de los hechos mediante la confirmación de los resultados de un git rm --cachedcomando independiente puede dar como resultado la eliminación de archivos recientemente ignorados en futuros tirones del control remoto forzado. El --prune-emptyindicador en el siguiente git filter-branchcomando evita este problema al eliminar automáticamente la confirmación de solo índice anterior "eliminar todos los archivos ignorados". Reescribir el historial de git también cambia los hash de confirmación, lo que causará estragos en futuros tirones de repositorios públicos / compartidos / colaborativos. Por favor, comprenda las ramificaciones completamente antes de hacer esto a dicho repositorio. Esta guía de GitHub especifica lo siguiente:

Dígale a sus colaboradores que modifiquen , no fusionen, las ramas que crearon a partir de su historial de repositorio antiguo (contaminado). Una confirmación de fusión podría reintroducir parte o la totalidad de la historia contaminada que acaba de tomarse la molestia de purgar.

Las soluciones alternativas que no afectan al repositorio remoto son git update-index --assume-unchanged </path/file>o git update-index --skip-worktree <file>, ejemplos de las cuales se pueden encontrar aquí .

Si alguien tiene dificultades en Windows y desea ignorar toda la carpeta, 'cd' a la carpeta deseada y haga 'Git Bash Here'.

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

En mi caso aquí, tenía varios archivos .lock en varios directorios que necesitaba eliminar. Ejecuté lo siguiente y funcionó sin tener que ir a cada directorio para eliminarlos:

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

Hacer esto fue a cada carpeta debajo de la 'raíz' de donde estaba y excluyó todos los archivos que coincidían con el patrón.

Espero que esto ayude a otros!