¿Cómo hacer que Git se “olvide” de un archivo que fue rastreado pero que ahora está en .gitignore?

Hay un archivo que estaba siendo rastreado por git, pero ahora el archivo está en el .gitignore lista.

Sin embargo, ese archivo sigue apareciendo en git status después de editarlo. Como fuerza git para olvidarlo por completo?

preguntado el 13 de agosto de 09 a las 16:08

git clean -X suena similar, pero no se aplica en esta situación (cuando Git todavía está rastreando los archivos). Estoy escribiendo esto para cualquiera que busque una solución para no seguir la ruta incorrecta. -

La única respuesta real a esto está abajo, vea git update-index --assume-unchanged. Esta solución 1) mantiene el archivo en el servidor (índice), 2) le permite modificarlo libremente de forma local. -

Tienes que usar --skip-worktree, Consulte: stackoverflow.com/questions/13630849/… -

Una pregunta importante es: ¿el archivo debe permanecer en el repositorio o no? Por ejemplo, si alguien clona el repositorio, ¿debería obtener el archivo o no? Si Si luego git update-index --assume-unchanged <file> es correcto y el archivo permanecerá en el repositorio y los cambios no se agregarán con git add. Si NO (por ejemplo, era un archivo de caché, archivo generado, etc.), luego git rm --cached <file> lo eliminará del repositorio. -

@Martin @Qwerty Everyon debería detenerse para asesorar --assume-unchanged que es para el rendimiento para evitar que git verifique el estado de los archivos de seguimiento grandes, pero prefiere --skip-worktree que es para archivos de seguimiento modificados que el usuario ya no quiere confirmar. Ver stackoverflow.com/questions/13630849/… -

27 Respuestas

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

Respondido el 16 de junio de 19 a las 17:06

el proceso que funcionó para mí fue 1. confirmar los cambios pendientes primero 2. git rm --cached y confirmar nuevamente 3. agregar el archivo a .gitignore, verificar con el estado de git y confirmar nuevamente - matar

Adición muy importante. Si el archivo que se ignora se modificaría (pero a pesar de esto no debería confirmarse), después de modificar y ejecutar git add . se agregaría al índice. Y la próxima confirmación lo enviaría al repositorio. Para evitar esto, ejecute justo después de todo lo que mataal dijo un comando más: git update-index --assume-unchanged <path&filename> - Dao

El método de @AkiraYamamoto también funcionó bien para mí. En mi caso, suprimí la salida ya que mi repositorio tenía miles de archivos: git rm -r -q --cached . - Aaron Blenkush

Esto eliminará el archivo en git pull aunque. - Petr Peller

git rm --caché simplemente elimine el archivo del repositorio, git update-index --assume-sin cambios no se muestra el archivo en los cambios sin etapas y no hace que se extraigan nuevos cambios. Pero quiero GIT SOLO IGNORAR EL CONTENIDO DEL ARCHIVO POR FAVOR - Igor Semin

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"

respondido 04 mar '21, 23:03

Para resaltar la diferencia entre esta respuesta y la aceptada: Con estos comandos, no es necesario que conozca los archivos afectados. (Imagine un directorio temporal con muchos archivos aleatorios que deberían borrarse del índice). - Ludwig

Igual que la respuesta aceptada. Los archivos se eliminarán el git pull. - Petr Peller

Sería bueno tener esto como un comando git estándar. Algo como git rmignored. - Berik

@gudthing -r significa "recursivo" - Mark

Con esto puedes terminar agregando otros archivos inútiles que no están actualmente en .gitignore. Lo cual puede ser difícil de averiguar si, dependiendo del ruido que haga su git status es después de este comando. Un comando que solo quita Los archivos recién ignorados serían mejores. Por eso prefiero La respuesta de thSoft - kurzedmetal

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>

Respondido el 12 de enero de 21 a las 08:01

Esta IS la verdadera respuesta. Impresionante en realidad, muy simple, no contamina git status y realmente muy intuitivo. Gracias. - Pablo Olmos de Aguilera C.

git update-index --assume-unchanged <path> … hará que git ignore los cambios en las rutas especificadas, independientemente de .gitignore. Si extrae de un control remoto y ese control remoto tiene cambios en esta ruta, git fallará la fusión con un conflicto y deberá fusionar manualmente. git rm --cached <path> … hará que git deje de rastrear esa ruta. Si no agrega la ruta a .gitignore Verás el camino en el futuro git status. La primera opción tiene menos ruido en el historial de confirmación de git y permite que los cambios en el archivo "ignorado" se distribuyan en el futuro. - manicdee

Estoy bastante confundido en cuanto a cómo esta no es la respuesta aceptada. La respuesta aceptada aquí claramente no responde a la pregunta real que se hace. Esta respuesta ignora los cambios en el archivo que está en el repositorio, pero no lo elimina del repositorio. - Dave Cooper

Esta respuesta sería mucho más útil si explicara exactamente qué hace el comando dado, por ejemplo, en qué se diferencia de las otras soluciones sugeridas. - LarsH

este comando solo será efectivo en su máquina, ¿verdad? ¿Qué pasa si quiero dejar de rastrear el archivo en todas las máquinas? también en las máquinas que clonarán el representante en el futuro? - George

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.

Respondido el 23 de enero de 18 a las 15:01

Si también necesita eliminarlos del directorio de trabajo, simplemente ejecute git ls-files --ignored --exclude-standard | xargs git rm . ¡Creo que esta respuesta es la mejor! Porque es muy claro, a la manera de Unix, y hace lo que se busca de manera directa, sin componer los efectos secundarios de otros comandos más complejos. - imz - Ivan Zakharyaschev

Gran respuesta; sin embargo, el comando fallará si tiene rutas con espacios en el medio, por ejemplo: "My dir / my_ignored_file.txt" - David Hernandez

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

git rm se quejará si ls-files no coincide con nada. Usar xargs -r git rm ... para contar xargs no correr git rm si ningún archivo coincide. - Wolfgang

Sería mejor usar \ 0 como separador: git ls-files --ignored --exclude-standard -z|xargs -0 git rm --cached - Nils-o-mat

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.

Respondido el 19 de junio de 15 a las 16:06

¡Gran solución! Funcionó perfectamente y se siente más correcto que eliminar todos los archivos y luego volver a agregarlos. Jon Catmull

Yo también encontré esto "más limpio". Puede ser obvio, pero al ejecutar la primera parte, git ls-files --ignored --exclude-standard, por sí solo le permite comprender / verificar primero qué archivos .gitignore va a excluir / eliminar, antes de continuar y ejecutar la final git rm. - jonvaliente

Tenga en cuenta que falla en los nombres de archivo con ciertos caracteres "desagradables" en ellos, p. Ej. \n. He publicado mi solución para atender esto. - jonvaliente

Otra advertencia: al extraer, esto hará que el archivo se elimine en los directorios de trabajo de otros, ¿verdad? - LarsH

lo intenté, pero no funcionó para mí: sed: 1: "s/.*/": unterminated substitute in regular expression en un comando filter-branch en un repositorio con espacios. (Sin embargo, parecía funcionar fuera de la rama del filtro). solía git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached de @ JonBrave's https://www.youtube.com/watch?v=xB-eutXNUMXJtA&feature=youtu.be en lugar de. - goofología

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.

Respondido 13 ago 09, 20:08

Esto funcionó muy bien si desea ignorar un montón de archivos que no fueron ignorados previamente. Aunque como dijiste, probablemente haya una mejor manera de hacerlo. - Oskar Persson

Eso es exactamente lo que hice. Simplemente mueva los archivos a una carpeta fuera de git, luego haga "git add.", "Git commit". (Esto eliminó los archivos) luego agregue el gitignore, haciendo referencia a los archivos / carpetas, confirme nuevamente para agregar el archivo gitignore a git, luego copie / mueva hacia atrás en las carpetas, y deben ignorarse. NB: parecerá que los archivos se eliminaron de GIT, por lo que probablemente los eliminaría de otras comprobaciones / extracciones, como se mencionó en las soluciones anteriores, pero dado que está haciendo copias de ellos inicialmente, esto no es un gran problema en mi humilde opinión. solo avísele al resto del equipo ... - Del

Esta es la forma más sencilla de deshacerse de carpetas comprometidas incorrectamente. - Martlark

Parece ser la única forma que puedo ver. Es un error masivo (no una 'característica') en git que tan pronto como agrega un archivo / carpeta a .gitignore, no solo ignora ese archivo a partir de ese momento, para siempre, en todas partes. - JoseK

Esto funcionó después de que los agregué, y luego, después del hecho, los agregué a .gitignore - hanzolo

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.

Respondido 22 Abr '18, 19:04

¿No eliminará los archivos del repositorio remoto? ¿Qué pasa si quiero mantener los archivos tanto en el repositorio local como en el repositorio remoto pero hacer que git se "olvide" de ellos? - Avishay28

AFAIK, esto no eliminará archivos del historial porque no estamos usando ningún comando de cambio de historial (corríjame si me equivoco). Esto solo agrega una nueva confirmación al eliminar los archivos ignorados en gitignore de git. Esos archivos estarán allí en los compromisos históricos - Dheeraj Bhaskar

Si tu no puedes git rm un archivo rastreado porque otras personas pueden necesitarlo (advertencia, incluso si 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).

respondido 24 nov., 18:04

git no eliminaría el archivo, si estuviera sucio en el momento de la eliminación. Y si no está sucio, recuperar el archivo sería tan fácil como git checkout <oldref> -- <filename> - pero luego sería verificado e ignorado. - menciones

Con respecto a su última nota (sobre --assume-unchanged): o esto es un culto a la carga y debe descartarse, o puede explicar por qué (de lo que estoy convencido) y se vuelve útil. - RomainValeri

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.

Respondido 25 Abr '17, 15:04

Esto cambiará todos los ID de confirmación, rompiendo así las fusiones de las ramas fuera de su copia del repositorio. - bdonlan

ADVERTENCIA: esto eliminará el archivo de todo su historial. Sin embargo, esto era lo que estaba buscando, eliminar un archivo completamente innecesario y de gran tamaño (salida que nunca debería haberse comprometido) que se comprometió hace mucho tiempo en el historial de versiones. - zebediah49

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.

Respondido el 20 de junio de 20 a las 10:06

Para mi esta es la mejor solución. Tiene un rendimiento mucho mejor que un git add .. También contiene las mejores mejoras de algunos comentarios anteriores. - Nils-o-mat

¿Puedes agregar thSoft's git commit -am "Remove ignored files" luego a tu respuesta? Tus respuestas combinadas me ayudaron a superar las cosas: j - Kando

No entiendo el propósito de git commit -a. Para mi git rm --cached afectar exactamente al índice, por lo que no es necesario preparar los archivos después de ... - Juan Pablo

  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.

Respondido 04 Oct 16, 01:10

¿Qué tal si votamos negativamente debido al hecho de que en realidad no funcionará ya que necesita un -r para ejecutar rm de forma recursiva de todos modos :) (Alguien no copió correctamente) - Aran Mulholland

Advertencia: esta técnica en realidad no hace que git ignore el archivo, sino que en realidad hace que git elimine el archivo. Eso significa que si usa esta solución, cada vez que alguien más haga un git pull, el archivo se eliminará. Entonces, en realidad, no se ignora. Consulte la solución que sugiere git update-index --assume-unchanged en su lugar para obtener una solución a la pregunta original. - orden

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

respondido 19 mar '20, 05:03

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.

contestado el 21 de mayo de 17 a las 16:05

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.

respondido 19 nov., 18:11

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

Respondido el 09 de Septiembre de 20 a las 03:09

¡Usted señor es el verdadero MVP! - Paul-Sebastián Manole

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 .

Respondido el 25 de diciembre de 13 a las 00:12

¿En qué situación esta lista de archivos no será igual al recursivo --cached? - Juan Zabroski

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

Respondido el 17 de diciembre de 10 a las 21:12

git rm --cached eliminará el archivo del índice sin eliminarlo del disco, por lo que no es necesario moverlo / copiarlo - bdonlan

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.

contestado el 09 de mayo de 19 a las 03:05

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

Respondido el 03 de Septiembre de 17 a las 13:09

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.

respondido 15 mar '18, 11:03

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

Respondido 08 ago 18, 21:08

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

Respondido el 14 de junio de 18 a las 10:06

Me alegro de que Git ahora haga esto. Sin embargo, el OP estaba preguntando sobre no rastrear las modificaciones en los archivos presentes en el .gitignore, no los archivos eliminados que aún muestran un estado. - tortuga

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

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

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

1 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

2 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í.

Respondido el 20 de junio de 20 a las 10:06

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!

Respondido 22 Abr '18, 22:04

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.

Respondido 05 Abr '19, 19:04

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

Respondido el 14 de diciembre de 19 a las 04:12

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!

Respondido el 27 de diciembre de 19 a las 22:12

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.