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

5406

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?

Ivan
fuente
16
git clean -XSuena similar, pero no se aplica en esta situación (cuando Git sigue rastreando los archivos). Estoy escribiendo esto para cualquiera que busque una solución para no seguir la ruta incorrecta.
imz - Ivan Zakharyaschev
35
La única respuesta real a esto está abajo, ver git update-index --assume-unchanged. Esta solución 1) mantiene el archivo en el servidor (índice), 2) le permite modificarlo libremente localmente.
Qwerty
8
Debe usar --skip-worktree, consulte: stackoverflow.com/questions/13630849/…
Doppelganger
77
Una pregunta importante es: ¿el archivo debe permanecer en el repositorio o no? Por ejemplo, si alguien nuevo clona el repositorio, ¿debería obtener el archivo o no? En caso afirmativo, entonces git update-index --assume-unchanged <file>es correcto y el archivo permanecerá en el repositorio y no se agregarán cambios con git add. Si NO (por ejemplo, era un archivo de caché, un archivo generado, etc.), git rm --cached <file>lo eliminará del repositorio.
Martin
99
@Martin @Qwerty Todos deberían detenerse para aconsejar --assume-unchangedcuál es el rendimiento para evitar que git verifique el estado de los archivos rastreados grandes, pero prefiera --skip-worktreecuál es para los archivos rastreados modificados que el usuario ya no desea comprometer. Ver stackoverflow.com/questions/13630849/…
Philippe

Respuestas:

5708

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

CB Bailey
fuente
55
el proceso que funcionó para mí fue 1. confirmar los cambios pendientes primero 2. git rm --cached <file> y commit nuevamente 3. agregar el archivo a .gitignore, verificar el estado de git y confirmar nuevamente
mataal
117
Muy importante agregar. Si el archivo que se ignora se modificará (pero a pesar de esto no se debe confirmar), después de modificarlo y ejecutarlo git add .se agregará al índice. Y el próximo commit lo comprometería al repositorio. Para evitar esto, ejecute justo después de todo ese mataal dijo un comando más:git update-index --assume-unchanged <path&filename>
Dao
32
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
85
Sin git pullembargo, esto eliminará el archivo .
Petr Peller
22
git rm --cached <file> solo elimina el archivo del repositorio, git update-index --assume -changed <file> no se muestra el archivo en los cambios no organizados y no hace que extraiga nuevos cambios. Pero quiero GIT IGNORE CONTENIDO DEL ARCHIVO POR FAVOR
Igor Semin
2611

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"
Matt Frear
fuente
197
Para resaltar la diferencia entre esta respuesta y la aceptada: al usar estos comandos, no necesita conocer realmente los archivos afectados. (Imagine un directorio temporal con muchos archivos aleatorios que deberían borrarse del índice).
Ludwig
53
Igual que la respuesta aceptada. Los archivos se eliminarán el git pull.
Petr Peller
73
Sería bueno tener esto como un comando git estándar. Algo así como git rmignored.
Berik
12
@gudthing -r significa "recursivo"
Mark
14
Con esto, puede terminar agregando otros archivos inútiles que no se encuentran actualmente .gitignore. Lo que puede ser difícil de averiguar si depende de qué tan ruidoso git statusesté después de este comando. Sería mejor un comando que solo elimine los archivos ignorados recientemente. Es por eso que prefiero la respuesta de
thSoft
1122

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>
Konstantin
fuente
173
Esta es la verdadera respuesta. Impresionante en realidad, muy simple, no contamina git statusy en realidad es muy intuitivo. Gracias.
Pablo Olmos de Aguilera C.
44
Fui por la rm [...] .solución lo suficientemente buena , ya que al menos pude entender cómo funcionaba. No encontré una gran documentación sobre qué update-indexy --assume-unchangedhacer. ¿Alguien puede agregar cómo se compara esto con el otro, ya que me gustaría eliminar todos los archivos que habrían sido ignorados? (¿O un enlace a una explicación clara?)
Brady Trainor
25
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á fusionarse manualmente. git rm --cached <path> …hará que git deje de rastrear ese camino. Si no agrega la ruta .gitignore, verá la ruta 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
26
Estoy bastante confundido sobre cómo esta no es la respuesta aceptada. La respuesta aceptada aquí claramente no responde la pregunta real que se hace. Esta respuesta ignora los cambios en el archivo que está en el repositorio mientras no lo elimina del repositorio.
Dave Cooper
11
Esta respuesta sería mucho más útil si explicara exactamente lo que hace el comando dado, por ejemplo, cómo es diferente de las otras soluciones sugeridas.
LarsH
283
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.

thSoft
fuente
77
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, Unix-way, y hace lo deseado de manera directa, sin componer los efectos secundarios de otros comandos más complejos.
imz - Ivan Zakharyaschev
66
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
8
git ls-files --no ignorado --exclude-standard | sed 's /.*/"&"/' | xargs git rm --cached
David Hernandez
3
git rmse quejará si ls-filesno coincide con nada. Use xargs -r git rm ...para indicar que xargsno se ejecute git rmsi no hay archivos coincidentes.
Wolfgang
10
Sería mejor usar \ 0 como separador:git ls-files --ignored --exclude-standard -z|xargs -0 git rm --cached
Nils-o-mat
83

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.

David Hernández
fuente
3
¡Gran solución! Funcionó perfectamente y se siente más correcto que eliminar todos los archivos y luego volver a agregarlos.
Jon Catmull
55
Yo también encontré esto "más limpio". Puede ser obvio, pero solo ejecutar la primera parte, git ls-files --ignored --exclude-standardpor sí solo, le permite primero comprender / verificar qué archivos su nuevo .gitignoreva a excluir / eliminar, antes de continuar y ejecutar el final git rm.
JonBrave
Tenga en cuenta, falla en los nombres de archivo con ciertos caracteres "desagradables" en ellos, por ejemplo \n. He publicado mi solución para atender esto.
JonBrave
3
Otra advertencia: en la extracción, esto hará que el archivo se elimine en los directorios de trabajo de otros, ¿verdad?
LarsH
intenté, pero no funcionó para mí: sed: 1: "s/.*/": unterminated substitute in regular expressionen un comando filter-branch en un repositorio con espacios. (Sin embargo, parecía funcionar fuera de la rama de filtro). En su lugar, utilicé la respuestagit ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached de @ JonBrave .
Goofología
71

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.

Joel Hooks
fuente
2
Esto funcionó muy bien si desea ignorar un montón de archivos que no se ignoraron anteriormente. Aunque, como dijiste, probablemente haya una mejor manera de hacerlo.
Oskar Persson
Esto 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, vuelva a comprometerse a agregar el archivo gitignore a git, luego copie / mueva de nuevo en las carpetas, y deben ignorarse. NB: parecerá que los archivos se eliminaron de GIT, por lo que probablemente los eliminaría de otros procesos de extracción / extracción, como se menciona en las soluciones anteriores, pero dado que está haciendo copias de ellos inicialmente, esto no es un problema en mi humilde opinión. solo deja que el resto del equipo sepa ...
Del
Esta es la forma más fácil de deshacerse de las carpetas erróneamente comprometidas.
Martlark
2
Parece ser la única forma, que puedo ver. Es un error masivo (no '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.
JosephK
Esto funcionó después de que los agregué, y luego de que el hecho los agregó a .gitignore
hanzolo el
66

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).
Seth Robertson
fuente
77
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 desprotegido e ignorado.
amenthes
Con respecto a su última nota (sobre --assume-unchanged): o bien se trata de culto a la carga y debe descartarse, o puede explicar por qué (de lo que estoy convencido) y se vuelve útil.
RomainValeri
57

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.

Dheeraj Bhaskar
fuente
1
¿No eliminará los archivos del repositorio remoto? ¿Qué sucede si quiero mantener los archivos tanto en el repositorio local como en el 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ígeme si estoy equivocado). 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
49

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

drrlvn
fuente
99
Esto cambiará todas las ID de confirmación, rompiendo así las fusiones de ramas fuera de su copia del repositorio.
bdonlan
19
ADVERTENCIA: esto eliminará el archivo de todo su historial. Sin embargo, esto era lo que estaba buscando, para eliminar un archivo completamente innecesario y de gran tamaño (salida que nunca debería haberse confirmado) que se confirmó hace mucho tiempo en el historial de versiones.
zebediah49
48

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.

JonBrave
fuente
1
Para mí esta es la mejor solución. Tiene mucho mejor rendimiento que a git add .. También contiene las mejores mejoras de algunos comentarios anteriores.
Nils-o-mat
¿Puedes agregar thSoft git commit -am "Remove ignored files"después a tu respuesta? Sus respuestas combinadas me
ayudaron
No entiendo el propósito de git commit -a. Para mí git rm --cachedafecta exactamente el índice, por lo que no es necesario organizar los archivos después de ...
Jean Paul
23
  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.

Chen_Wayne
fuente
1
¿Qué tal un voto negativo debido al hecho de que en realidad no funcionará ya que necesita un -r para ejecutar rm recursivamente de todos modos :) (Alguien no copió correctamente)
Aran Mulholland
1
Advertencia: esta técnica en realidad no hace que git ignore el archivo, sino que 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á. Por lo tanto, en realidad no se ignora. Vea la solución que sugiere git update-index --assume-unchanged en su lugar para una solución a la pregunta original.
orden
16

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.

Boolean_Type
fuente
16

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
Shamsul Arefin Sajib
fuente
13

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.

youhans
fuente
9

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 .
Ameer Deen
fuente
¿En qué situación esta lista de archivos no será igual a la recursiva --cached?
John Zabroski
8

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

Apreche
fuente
34
git rm --cachedeliminará el archivo del índice sin eliminarlo del disco, por lo que no es necesario moverlo / copiarlo
bdonlan
7

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.

Esqueletos
fuente
5

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

Meir Gerenstadt
fuente
5

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.

Peter T.
fuente
5

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
Jay Irvine
fuente
4

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
Lloyd
fuente
Me alegro que git ahora haga esto. Sin embargo, el OP estaba preguntando por no rastrear las modificaciones en los archivos presentes en .gitignore, los archivos no eliminados aún muestran un estado.
mrturtle
2

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!


fuente
2

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.

curioso
fuente
2

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

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

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

1 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

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

goofología
fuente
0

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
RajVimalC
fuente
0

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!

DC.Skells
fuente