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 editarlo. ¿Cómo te obligas gita olvidarlo por completo?

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

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 ocurrirá en la próxima confirmación.

ADVERTENCIA: Si bien esto no eliminará el archivo físico de su local, eliminará los archivos de las máquinas de otros desarrolladores a continuación 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 git ignora. PD. Índice = caché

Primero:

git rm -r --cached . 
git add .

Entonces:

git commit -am "Remove ignored files"

O de una sola 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.

Actualizar, una mejor opción

Desde que se publicó esta respuesta, se ha creado una nueva opción y esa debería ser la preferida. Debe usar el --skip-worktreeque es para archivos de seguimiento modificados que el usuario ya no quiere comprometer y conservar --assume-unchangedpara el rendimiento para evitar que git verifique el estado de los archivos de seguimiento grandes. Verhttps://stackoverflow.com/a/13631525/717372 para 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. Salida limpia de una línea, estilo Unix:

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

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

muévalo, confírmelo y luego vuelva a colocarlo. Esto me ha funcionado en el pasado. Probablemente haya una forma más 'gittier' de lograr esto.

Si no puede git rmun archivo rastreado porque otras personas podrían necesitarlo (advertencia, incluso si usted git rm --cached , cuando alguien más recibe este cambio, sus archivos se eliminarán en su sistema de archivos). Esto a menudo se hace debido a anulaciones de archivos de configuración, credenciales de autenticación, etc.https://gist.github.com/1423106 por las formas en que la gente ha solucionado el problema.

Para resumir:

• Haga que su aplicación busque un archivo config-overide.ini ignorado y utilícelo sobre el archivo comprometido 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 si es necesario.
• Intente usar gitattributes clean / smudge magic para aplicar y eliminar los cambios por usted, por ejemplo, difuminar el archivo de configuración como un pago de una rama alternativa y limpiar el archivo de configuración como un pago de HEAD. Esto es complicado, no lo recomiendo para usuarios novatos.
• Mantenga el archivo de configuración en una rama de implementación dedicada a él que nunca se fusiona con el maestro. Cuando desee implementar / compilar / probar, se fusiona con esa rama y obtiene ese archivo. Este es esencialmente el enfoque de mancha / limpieza, excepto que se utilizan políticas de combinación humana y módulos extra-git.
• Anti-recommentación: No uses la función de asumir sin cambios, solo terminará en lágrimas (porque si git se miente a sí mismo hará que sucedan cosas malas, como que tu cambio se pierda para siempre).

Use esto cuando:

1. Desea eliminar el seguimiento de muchos archivos o

2. Actualizaste tu archivo gitignore

Enlace fuente: 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 de git y luego los agrega a su .gitignore; estos archivos todavía estarán presentes en su índice de repositorio. En este artículo veremos cómo deshacernos de ellos.

Paso 1: Confirme todos sus cambios

Antes de continuar, asegúrese de que se hayan confirmado todos los cambios, incluido su archivo .gitignore.

Paso 2: eliminar todo del repositorio

Para borrar su repositorio, use:

git rm -r --cached .

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

El rmmandato puede ser implacable. Si desea probar lo que hace de antemano, agregue la marca -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 :)

Presiona los cambios en tu 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 de manual:

ADVERTENCIA : esto eliminará el archivo de todo su historial

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

Este comando volverá a crear todo el historial de confirmaciones, 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á.

Que no funciono para mi

(Bajo 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 que se eliminarán 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).

Así que ofrezco

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

Esto usa el -zargumento para ls-files y el -0argumento para xargs para atender de manera segura / correcta a los caracteres "desagradables" en los nombres de los archivos.

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

Cuando no se usa la opción -z, los caracteres TAB, LF y barra invertida 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 desee realizar un seguimiento .gitignore.

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

3. git add .- Todos los archivos se volverán a agregar, excepto los que están en formato .gitignore.

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

Realice los siguientes pasos en serie, estará bien.

1. elimine los archivos agregados por error del directorio / almacenamiento . Puede utilizar el comando "rm -r" (para linux) o eliminarlos navegando por los directorios. O muévelos a otra ubicación en tu PC. [Quizás debas cerrar el IDE si se está ejecutando para moverlos / quitarlos ]

2.Agregue los archivos / directorios al gitignorearchivo ahora y guárdelo.

3.Ahora elimínelos de la caché de git usando 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 haga una confirmación y presione , use 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

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

Este problema está ausente, por ejemplo, cuando se utiliza 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 confirma 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. Por lo tanto, si agregó un 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 pasarán a remoto. Si el archivo se cambia en el control remoto, se producirá un conflicto cuando git pull. Stash no funcionará. Para resolverlo, copie el contenido del archivo a un 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 de un lugar seguro al archivo y vuelva a realizar:

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

Si todos los que trabajan con el proyecto funcionan git update-index --skip-worktree <file>, los problemas 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 el control remoto, pero puede protegerlo de que el contenido remoto lo sobrescriba.

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

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

La respuesta de Matt Fear fue la más efectiva en mi humilde opinión. El siguiente es solo un script de PowerShell para que aquellos en Windows solo eliminen archivos de su repositorio de git que coincidan 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 un lugar seguro para no perderlo. Luego, git rm el archivo y confirme. El archivo seguirá apareciendo si vuelve a una de esas confirmaciones anteriores u otra rama en la que 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 volver a moverlo a la carpeta y git no lo verá.

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

¿Cómo se fuerza gita olvidarse por completo de [un archivo]?

De hecho, esta solución hará que el archivo se elimine en todas las demás instancias del repositorio al ejecutar un git pull!

La forma correcta de forzar a git a olvidarse de un archivo está documentada por GitHub aquí .

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úrese de haber agregado el archivo a su .gitignore.

También deberá permitir (temporalmente) los empujes que no sean de avance rápido a su repositorio , ya que está cambiando su historial de git.

Realice los siguientes pasos para el archivo / carpeta:

Remover archivo:

1. Necesito agregar ese archivo a .gitignore.
2. Necesito eliminar ese archivo usando el comando ( git rm - nombre de archivo en caché ).
3. necesita ejecutar ( git add. ).
4. necesita ( confirmar -m ) "archivo eliminado".
5. y finalmente, ( git push ).

Por ejemplo:

Quiero eliminar el archivo test.txt. Accidentalmente empujé a GitHub y quiero eliminar los comandos que se seguirán como:

Primero agregue test.txt en .gitignore

git rm --cached test.txt
git add .
git commit -m "test.txt removed"
git push

Eliminar carpeta:

1. Necesito agregar esa carpeta a .gitignore.
2. necesita eliminar esa carpeta usando el comando ( git rm -r - nombre de la carpeta en caché ).
3. necesita ejecutar ( git add. ).
4. necesita ( confirmar -m ) "carpeta eliminada".
5. y finalmente, ( git push ).

Por ejemplo:

Quiero eliminar la carpeta / dir .idea. Accidentalmente empujé a GitHub y quiero eliminar los comandos que se seguirán como:

Primero agregue .idea en .gitignore

git rm -r --cached .idea
git add .
git commit -m ".idea removed"
git push

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

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

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

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

El BFG es 10-1000 veces más rápido que git filter-branch y, en general, mucho más fácil de usar: consulte las instrucciones de uso completas y los 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 commit -a me asusta un poco, así que esto es lo que hice:

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 "nuevo gitignore y eliminar archivos ignorados del índice" '

descomponié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 la última versión de git (v2.17.1 en el momento de escribir este artículo).

El .gitignoreignora finalmente ubicó pero-archivos borrados. Puede probar esto por sí mismo ejecutando el siguiente script. La git statusdeclaración final debe informar "nada que comprometer".

# 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

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 del control remoto).

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

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

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

Además, el historial de comentarios / revisiones de esta respuesta ( y el historial de revisiones 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, siga 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 usando las instrucciones anteriores, quizás los detalles sobre cómo obtener un .gitignorearchivo en las confirmaciones históricas que lo necesitan están más allá del alcance de esta respuesta. Quería que un correcto .gitignoreestuviera en la confirmación raíz, como si fuera lo primero que hice. A otros puede que no les importe, ya que /.git/info/excludepueden lograr lo mismo independientemente de dónde .gitignoreexista en el historial de confirmaciones, y claramente reescribir la historia es un tema muy delicado, incluso cuando se conocen 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 del hecho mediante la confirmación de los resultados de un git rm --cachedcomando independiente puede resultar en la eliminación del archivo recién ignorado en futuras extracciones del control remoto forzado. El --prune-emptyindicador en el siguiente git filter-branchcomando evita este problema al eliminar automáticamente la confirmación previa de solo índice "eliminar todos los archivos ignorados". Reescribir el historial de git también cambia los hashes de confirmación, lo que causará estragos en las futuras extracciones de repositorios públicos / compartidos / colaborativos. Por favor, comprenda las ramificaciones completamente antes de hacer esto en dicho repositorio. Esta guía de GitHub especifica lo siguiente:

Dígales a sus colaboradores que vuelvan a basar , no fusionen, las ramas que hayan creado a partir de su historial de repositorio antiguo (contaminado). Un compromiso de fusión podría reintroducir parte o todo el historial contaminado 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í .

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, el slnx.sqlite, simplemente 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 y preferencias de usuario locales para proyectos (como los archivos que tenía abiertos). Entonces, cada vez que navega o realiza algunos cambios en su IDE, ese archivo cambia y, por lo tanto, lo verifica y muestra que hay cambios no confirmados.

Si alguien tiene dificultades con Windows y desea ignorar la carpeta completa, haga "cd" para seleccionar la "carpeta" 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

Al hacer esto, ingresé 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!