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

gitignore specific file

Question

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

Sin embargo, ese archivo sigue apareciendo en git status después de editarlo. ¿Cómo git a git a olvidarlo por completo?

Answer 1

Use esto cuando:

1. Desea desmarcar muchos archivos, o

2. Has actualizado tu archivo gitignore.

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

Digamos que ya ha agregado / confirmado algunos archivos en su repositorio git y luego los agrega a su .gitignore; Estos archivos todavía estarán presentes en el índice de su repositorio. En este artículo veremos cómo deshacernos de ellos.

Paso 1: Confirma todos tus cambios.

Antes de continuar, asegúrese de que todos los 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. Sus archivos todavía estarán allí.

El comando rm puede ser implacable. Si desea probar lo que hace de antemano, agregue la --dry-run -n o --dry-run para probar las cosas.

Paso 3: Re agregar todo

git add .

Paso 4: cometer

git commit -m ".gitignore fix"

Tu repositorio está limpio :)

Presiona los cambios en tu control remoto para ver los cambios efectivos allí también.

Answer 2

Lo que no me funcionó

(Bajo Linux), quise usar las publicaciones aquí sugiriendo los ls-files --ignored --exclude-standard | xargs git rm -r --cached ls-files --ignored --exclude-standard | xargs git rm -r --cached enfoque en ls-files --ignored --exclude-standard | xargs git rm -r --cached . Sin embargo, (algunos de) los archivos que se eliminarán tenían una nueva línea / LF / /n incrustada 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 acerca de los archivos no encontrados).

Entonces ofrezco

git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached

Esto usa el argumento -z para ls-files , y el argumento -0 para xargs para atender con seguridad / correctamente los caracteres "desagradables" en los nombres de archivo.

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

Cuando no se usa la opción -z, los caracteres TAB, LF y barra diagonal inversa en las rutas se representan como / t, / n y //, respectivamente.

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

EDITAR: Se me ha pedido que agregue --- como cualquier comando de git rm --- esto debe ir seguido de un compromiso para que las eliminaciones sean permanentes, por ejemplo, git commit -am "Remove ignored files" .

Answer 3

1. Actualice su archivo .gitignore ; por ejemplo, agregue una carpeta que no desea rastrear en .gitignore .

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

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

Sombrero de punta a @AkiraYamamoto por indicarnos en la dirección correcta.

Answer 4

Creo que tal vez git no puede olvidarse totalmente 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 confirma o guarda el estado de su proyecto, básicamente toma una fotografía de cómo se ven todos sus archivos en ese momento y almacena una referencia a esa instantánea. Por lo tanto, si agregó un archivo una vez, siempre estará presente en esa instantánea.

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

git supone sin cambios frente a 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 al control remoto. Si se cambia el archivo en el control remoto, se producirá un conflicto cuando git pull . El alijo no funcionará. Para resolverlo, copie el contenido del archivo en 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 del lugar seguro al archivo y realice nuevamente:

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

Si todas las personas que trabajan con el proyecto realizarán git update-index --skip-worktree <file> , los problemas con la pull deberían estar ausentes. Esta solución está bien para los 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 por contenido remoto.

Answer 5

El BFG está diseñado específicamente para eliminar datos no deseados como archivos grandes o contraseñas de los repositorios de 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, puede hacerlo también:

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

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

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

Answer 6

En caso de que DS_Store ya DS_Store comprometido:

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

Ignorarlos 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

Por último, hacer un compromiso!

Answer 7

Haz los siguientes pasos en serie, estarás bien.

1. eliminar los archivos agregados por error del directorio / almacenamiento . Puede usar el comando "rm -r" (para linux) o eliminarlos al navegar por los directorios.

2.add los archivos / directorios al archivo gitignore ahora y guárdelo.

3. ahora elimínelos de git cache usando estos comandos (si hay más de un directorio, elimínelos uno por uno emitiendo este comando repetidamente)

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

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

Answer 8

La respuesta de Matt Fear fue la IMHO más efectiva. La siguiente es solo una secuencia de comandos de PowerShell para aquellos en Windows que solo eliminan archivos de su repositorio 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 .

Answer 9

La siguiente serie de comandos 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 ignorantes de Git. PD. Índice = Caché

Primero:

git rm -r --cached . 
git add .

Entonces:

git commit -am "Remove ignored files"

Answer 10

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

ADVERTENCIA : esto eliminará el archivo de su historial completo

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

Este comando volverá a crear todo el historial de confirmación, ejecutando git rm antes de cada confirmación y, por lo tanto, eliminará el archivo especificado. No olvide realizar una copia de seguridad antes de ejecutar el comando, ya que se perderá.

Answer 11

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

git config --global alias.exclude-ignored ''! git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached && git ls-files -z --ignored --exclude-standard | xargs -0 git stage && git stage .gitignore && git commit -m "nuevo gitignore y eliminar archivos ignorados del índice" ''

rompiéndolo abajo

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

Answer 12

Mueva o copie el archivo a un lugar seguro, para que no lo pierda. Entonces git rm el archivo y cometer. El archivo seguirá apareciendo si vuelves a una de esas confirmaciones anteriores u otra rama donde no se haya eliminado. Sin embargo, en todas las confirmaciones futuras, no verá el archivo nuevamente. Si el archivo está en el git ignorar, entonces puede moverlo de nuevo a la carpeta, y git no lo verá.

Answer 13

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.

Answer 14

Si no puede obtener un archivo rastreado porque otras personas podrían necesitarlo (advertencia, incluso si git rm --cached , cuando alguien más obtenga 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. Mire https://gist.github.com/1423106 para conocer las formas en que las personas han resuelto el problema.

Para resumir:

• Haga que su aplicación busque un archivo config-overide.ini ignorado y lo use 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 si es necesario.
• Trate de usar gitattributes clean / smudge magic para aplicar y eliminar los cambios por usted, por ejemplo manchar 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 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 fusione con el maestro. Cuando desea implementar / compilar / probar, se fusiona con esa rama y obtiene ese archivo. Este es esencialmente el enfoque de borrado / limpieza, excepto el uso de políticas de fusión humana y módulos extra-git.
• Anti-recommentación: No utilice supuestos sin cambios, solo terminará en lágrimas.

Answer 15

Siempre utilizo 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 entrecomillada para manejar las rutas con espacios dentro, y pasa todo a git rm -r --cached para eliminar las rutas / archivos / dirs del índice.

Answer 16

muévalo hacia fuera, comprométase, luego vuélvalo a mover. Esto me ha funcionado en el pasado. Probablemente hay una manera ''más ingeniosa'' de lograr esto.

Answer 17

.gitignore evitará que se .gitignore archivos no rastreados (sin add -f ) al conjunto de archivos rastreados por git, sin embargo, git continuará rastreando cualquier archivo que ya esté siendo rastreado.

Para detener el seguimiento de un archivo, debe eliminarlo del índice. Esto se puede lograr con este comando.

git rm --cached <file>

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

Answer 18

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

El .gitignore finalmente ignora los archivos rastreados pero eliminados. Puede probar esto por sí mismo ejecutando el siguiente script. La declaración de git status final de git status 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

Answer 19

git update-index hace el trabajo por mí:

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

Nota: esta solución es realmente independiente en .gitignore ya que gitignore es solo para archivos sin seguimiento.

Editar: desde que se publicó esta respuesta, se ha creado una nueva opción y se debería preferir. Debe usar --skip-worktree que es para los archivos de seguimiento modificados que el usuario ya no quiere confirmar y mantener --assume-unchanged rendimiento para evitar que git verifique el estado de los archivos de gran seguimiento. Consulte https://.com/a/13631525/717372 para obtener más detalles ...

Answer 20

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.