.gitignore evitará que se agreguen archivos sin seguimiento (sin un add -f) 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 que contiene 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 en la próxima 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 de .gitignore ya 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. Deberías usar --skip-worktree que es para archivos de seguimiento modificados que el usuario ya no quiere comprometer y mantener --assume-unchanged para el rendimiento para evitar que git verifique el estado de los grandes archivos rastreados. Ver https://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 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 rutas con espacios dentro y pasar todo a git rm -r --cached para 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.

Use esto cuando:

1. Desea eliminar el seguimiento de 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 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 remoción
• -r permitirá la eliminación recursiva
• –Caché solo eliminará archivos del índice. Tus archivos seguirán ahí.

Programas de rm El comando puede ser implacable. Si desea probar lo que hace de antemano, agregue el -n or --dry-run bandera para 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 en su control remoto para ver los cambios efectivos allí también.

Si tu no puedes git rm un archivo rastreado porque otras personas pueden necesitarlo (advertencia, incluso si tí git rm --cached, cuando alguien más recibe este cambio, sus archivos se eliminarán en su sistema de archivos). Esto se hace a menudo 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.

En resumen:

• 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 según sea necesario 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 el usuario novato.
• 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).

Lo logré usando rama de filtro de git. 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 recreará todo el historial de confirmaciones, ejecutando git rm antes de cada confirmación y, por lo tanto, se eliminará el archivo especificado. No olvide hacer una copia de seguridad antes de ejecutar el comando, ya que seguirá estar perdido.

Que no funciono para mi

(Bajo Linux), quería usar las publicaciones aquí sugiriendo el ls-files --ignored --exclude-standard | xargs git rm -r --cached Acercarse. Sin embargo, (algunos de) los archivos que se eliminarán tenían un salto de línea / LF /\n en 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 -z argumento para archivos-ls, y la -0 argumento para xargs para atender de forma segura / correcta a los caracteres "desagradables" en los nombres de archivo.

En la página del manual archivos-git-ls (1), afirma:

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 .gitignore archivo: por ejemplo, agregue una carpeta a la que no desea rastrear .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 .gitignore.

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

Realice los siguientes pasos en serie, estará bien.

1.remove los archivos agregados por error desde el directorio / almacenamiento. Puede usar el comando "rm -r" (para Linux) o eliminarlos navegando por los directorios. O muévalos a otra ubicación en su PC. [Es posible que deba cerrar el IDE si está ejecutando moviendo / removiendo]

2.agregue los archivos / directorios a gitignore archivo ahora y guárdelo.

3.Ahora remove ellos de 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 do a comprometerse y empujar, utilice estos comandos. Esta voluntad eliminar esos archivos de git remote y hacer git dejar 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 lo que todos tus archivos parece 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 me resultaron útiles:

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, copiar 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 se desempeñarán git update-index --skip-worktree <file>, problemas con pull debe estar ausente. 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 a .gitignore.

Realice los siguientes pasos para el archivo / carpeta:

Remover archivo:

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

Por ejemplo:

Quiero eliminar el archivo test.txt. Accidentalmente empujé a GitHub para 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. Necesito eliminar esa carpeta con el comando (git rm -r: nombre de la carpeta en caché).
3. necesito corrergit add.).
4. Necesitar (cometer -m) "carpeta eliminada".
5. y finalmente, (git push).

Por ejemplo:

Quiero eliminar la carpeta / dir .idea. Accidentalmente empujé a GitHub para 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

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

Usando el git rm --cached El comando no responde a la pregunta original:

Como fuerza git olvidarse por completo de [un archivo]?

De hecho, esta solución hará que el archivo sea borrado en cualquier otra instancia 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

solo reemplaza full/path/to/file con la ruta completa del archivo. Asegúrese de haber agregado el archivo a su .gitignore.

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

Programas de 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-larger- 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. instrucciones de uso completas y ejemplos para más información.

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

Si no desea utilizar la CLI y está trabajando en Windows, una solución muy sencilla es utilizar 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 elimina los 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).

Programas de .gitignore finalmente ignora los archivos rastreados pero eliminados. Puede probar esto por sí mismo ejecutando el siguiente script. El final git status La declaración 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 "olvidar" sobre un archivo ... "(históricamente). Solo hace que git pasar por alto el archivo en el presente / futuro.

Este método hace que git olvidar completamente archivos ignoradospasado/ presente / futuro), pero no no elimine cualquier cosa del directorio de trabajo (incluso cuando se vuelva a extraer desde el control remoto).

Este método requiere el uso de /.git/info/exclude (de preferencia) OR a Preexistente .gitignore in todos 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 o índice de trabajo, y haz una copia de seguridad!

Además, los comentarios /revisión histórica of esta respuesta (e historial de revisiones of esta pregunta) puede ser útil / esclarecedor.

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

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 a pie de página

¹ Porque /.git/info/exclude se puede aplicar a todas las confirmaciones históricas usando las instrucciones anteriores, tal vez detalles sobre cómo obtener una .gitignore presentar dentro los compromisos históricos que lo necesitan están más allá del alcance de esta respuesta. Yo quería una adecuada .gitignore estar en la confirmación raíz, como si fuera lo primero que hice. A otros puede que no les importe ya que /.git/info/exclude puede lograr lo mismo independientemente de dónde .gitignore existe en el historial de compromisos, y claramente reescribir el historial es una tema delicado, incluso cuando es consciente de la ramificaciones.

FWIW, los métodos potenciales pueden incluir git rebase o con una git filter-branch que copia un externo .gitignore en cada compromiso, como las respuestas a esta pregunta

² Hacer cumplir git ignora el comportamiento después del hecho mediante la confirmación de los resultados de un git rm --cached El comando puede resultar en un archivo recién ignorado eliminación en el futuro tira del control remoto de empuje forzado. La --prune-empty bandera en el siguiente git filter-branch El comando evita este problema eliminando 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 transtornos en futuras extracciones de repositorios públicos / compartidos / colaborativos. Por favor, comprenda el ramificaciones completamente antes de hacer esto en dicho repositorio. Esta guía de GitHub especifica lo siguiente:

Dile a tus colaboradores que rebase, no fusionar, las ramas que crearon 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.

Soluciones alternativas que no afectar el repositorio remoto son git update-index --assume-unchanged </path/file> or git update-index --skip-worktree <file>, ejemplos de los cuales se pueden encontrar aquí.

En caso de ya comprometido DS_Store:

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

Ignórelos 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, me deshice de él 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 se 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, se dirigió a cada carpeta debajo de la 'raíz' de donde estaba y se excluyeron todos los archivos que coincidían con el patrón.

¡Espero que esto ayude a otros!