Comando Git para mostrar qué archivos específicos son ignorados por .gitignore

Me estoy mojando los pies con Git y tengo el siguiente problema:

El árbol fuente de mi proyecto:

/
|
+--src/
+----refs/
+----...
|
+--vendor/
+----...

Tengo un código (actualmente MEF) en mi sucursal de proveedor que compilaré allí y luego moveré las referencias a /src/refsdonde es donde el proyecto los recoge.

Mi problema es que tengo mi .gitignoreconjunto para ignorar *.dlly *.pdb. Puedo hacer una git add -f bar.dllpara forzar la adición del archivo ignorado, lo cual está bien, el problema es que no puedo encontrar una lista de los archivos que se ignoran.

Quiero enumerar los archivos ignorados para asegurarme de no olvidar agregarlos.

He leído la página de manual git ls-filesy no puedo hacer que funcione. Me parece que git ls-files --exclude-standard -idebería hacer lo que quiero. ¿Qué me estoy perdiendo?

Notas:

• La respuesta de xiaobai es más simple (git1.7.6 +): (como se detalla en " ¿Hay alguna forma de decirle a git-status que ignore los efectos de los archivos? ")git status --ignored
.gitignore
• MattDiPasquale 's respuesta (que se upvoted) git clean -ndXtrabaja en GITS de más edad, que muestra una vista previa de lo que ficheros ignorados podrían ser eliminados (sin eliminar nada)

También interesante (mencionado en la respuesta de qwertymk ), también puede usar el comando, al menos en Unix ( no funciona en una sesión CMD de Windows )git check-ignore -v

git check-ignore *
git check-ignore -v *

El segundo muestra la regla real .gitignoreque hace que un archivo sea ignorado en su repositorio de git.
En Unix, usando " ¿Qué se expande a todos los archivos en el directorio actual de forma recursiva? " Y un bash4 +:

git check-ignore **/*

(o un find -execcomando)

Nota: https://stackoverflow.com/users/351947/Rafi B. sugiere en los comentarios para evitar el (arriesgado) globstar :

git check-ignore -v $(find . -type f -print)

Sin .git/embargo, asegúrese de excluir los archivos de la subcarpeta.

Respuesta original 42009)

git ls-files -i

debería funcionar, excepto que su código fuente indica:

if (show_ignored && !exc_given) {
                fprintf(stderr, "%s: --ignored needs some exclude pattern\n",
                        argv[0]);

exc_given ?

Resulta que necesita un parámetro más después de la -ilista para realmente enumerar cualquier cosa:

Tratar:

git ls-files -i --exclude-from=[Path_To_Your_Global].gitignore

(pero eso solo enumeraría su objeto en caché (no ignorado), con un filtro, por lo que no es exactamente lo que desea)

Ejemplo:

$ cat .git/ignore
# ignore objects and archives, anywhere in the tree.
*.[oa]
$ cat Documentation/.gitignore
# ignore generated html files,
*.html
# except foo.html which is maintained by hand
!foo.html
$ git ls-files --ignored \
    --exclude='Documentation/*.[0-9]' \
    --exclude-from=.git/ignore \
    --exclude-per-directory=.gitignore

En realidad, en mi archivo 'gitignore' (llamado 'excluir'), encuentro una línea de comando que podría ayudarlo:

F:\prog\git\test\.git\info>type exclude
# git ls-files --others --exclude-from=.git/info/exclude
# Lines that start with '#' are comments.
# For a project mostly in C, the following would be a good set of
# exclude patterns (uncomment them if you want to use them):
# *.[oa]
# *~

Entonces....

git ls-files --others --ignored --exclude-from=.git/info/exclude
git ls-files -o -i --exclude-from=.git/info/exclude

git ls-files --others --ignored --exclude-standard
git ls-files -o -i --exclude-standard

debería hacer el truco.

Como se menciona en la página de manual de ls-files , --otherses la parte importante para mostrarle archivos no almacenados en caché, no comprometidos y normalmente ignorados.

--exclude_standardno es solo un atajo, sino una forma de incluir todas las configuraciones estándar de "patrones ignorados".

exclude-standard
Añadir las exclusiones estándar git: .git/info/exclude, .gitignoreen cada directorio, y el user's global exclusion file.

Hay una manera mucho más simple de hacerlo (git 1.7.6+):

git status --ignored

Ver ¿Hay alguna manera de decirle a git-status que ignore los efectos de los archivos .gitignore?

Otra opción que es bastante limpia (sin juego de palabras):

git clean -ndX

Explicación:

$ git help clean

git-clean - Remove untracked files from the working tree
-n, --dry-run - Don't actually remove anything, just show what would be done.
-d - Remove untracked directories in addition to untracked files.
-X - Remove only files ignored by Git.

Nota: Esta solución no mostrará los archivos ignorados que ya se han eliminado.

Si bien generalmente la solución es correcta, no funciona en todas las circunstancias. Supongamos un directorio de repositorio como este:

# ls **/*                                                                                                       
doc/index.html  README.txt  tmp/dir0/file0  tmp/file1  tmp/file2

doc:
index.html

tmp:
dir0  file1  file2

tmp/dir0:
file0

y un .gitignore como este:

# cat .gitignore
doc
tmp/*

Esto ignora el docdirectorio y todos los archivos a continuación tmp. Git funciona como se esperaba, pero el comando dado para enumerar los archivos ignorados no lo hace. Echemos un vistazo a lo que git tiene que decir:

# git ls-files --others --ignored --exclude-standard                                                            
tmp/file1
tmp/file2

Observe que docfalta en la lista. Puedes conseguirlo con:

# git ls-files --others --ignored --exclude-standard --directory                                                
doc/

Observe la --directoryopción adicional .

Que yo sepa, no hay un solo comando para enumerar todos los archivos ignorados a la vez. Pero no sé por qué tmp/dir0no aparece en absoluto.

Git ahora tiene esta funcionalidad incorporada

git check-ignore *

Por supuesto, puedes cambiar el globo a algo como **/*.dllen tu caso

Referencia de Git

Debería ser suficiente para usar

git ls-files --others -i --exclude-standard

ya que eso cubre todo lo cubierto por

git ls-files --others -i --exclude-from=.git/info/exclude

Por lo tanto, este último es redundante.

git config --global alias.ignored "ls-files --others -i --exclude-standard"

Ahora puede escribir git ignoredpara ver la lista. Mucho más fácil de recordar y más rápido de escribir.

Si prefiere la visualización más sucinta de la solución de Jason Geng, puede agregar un alias para eso como este:

git config --global alias.ignored "status --ignored -s"

Sin embargo, la salida más detallada es más útil para solucionar problemas con sus archivos .gitignore, ya que enumera todos los archivos de selección de algodón que se ignoran. Normalmente, canalizaría los resultados greppara ver si un archivo que espera ignorar está allí, o si un archivo que no desea ignorar está allí.

git ignored | grep some-file-that-isnt-being-ignored-properly

Luego, cuando solo desea ver una pantalla corta, es bastante fácil de recordar y escribir

git status --ignored

( -sNormalmente se puede dejar).

Aquí le mostramos cómo imprimir la lista completa de archivos en el árbol de trabajo que coinciden con los patrones ubicados en cualquier lugar de las múltiples fuentes de gitignore de Git (si está usando GNU find):

$ cd {your project directory}
$ find . -path ./.git -prune -o -print \
| git check-ignore --no-index --stdin --verbose

Verificará todos los archivos en la rama actual del repositorio (a menos que los haya eliminado localmente).

E identifica las líneas de origen de gitignore particulares, también.

Git continúa rastreando los cambios en algunos archivos que coinciden con los patrones de gitignore, simplemente porque esos archivos ya se agregaron. Útilmente, el comando anterior también muestra esos archivos.

Los patrones negativos de gitignore también se corresponden. Sin embargo, estos son fácilmente distinguibles en la lista, porque comienzan con !.

Si está utilizando Windows, Git Bash incluye GNU find(como lo revela find --version).

Si la lista es larga (y la tiene rev), también puede mostrarlos por extensión (algo):

$ cd {your project directory}
$ find . -path ./.git -prune -o -print \
| git check-ignore --no-index --stdin --verbose \
| rev | sort | rev

Para más detalles, ver man find, man git-check-ignore, man rev, y man sort.

El punto de todo este enfoque es que Git (el software) está cambiando rápidamente y es altamente complejo. Por el contrario, los GNU findson extremadamente estables (al menos, en sus características utilizadas aquí). Por lo tanto, cualquiera que desee ser competitivo al mostrar su profundo conocimiento de Git responderá la pregunta de una manera diferente.

¿Cuál es la mejor respuesta? Esta respuesta minimiza deliberadamente su dependencia del conocimiento de Git, para lograr el objetivo de estabilidad y simplicidad a través de la modularidad (aislamiento de la información), y está diseñado para durar mucho tiempo.

_{(extendiendo las otras respuestas)}

Tenga en cuenta que git check-ignoreusa el comprometido .gitignorey no el que está en su árbol de trabajo. Para jugar con él sin contaminar su historial de git, puede intentar editarlo libremente y luego comprometerse con a git commit --amend.

Este problema ocurre principalmente si necesita una solución alternativa del problema, que git no sigue directorios. Ingrese en .gitignore:

dirtokeep/**
!dirtokeep/.keep

.keepdebería ser un archivo de longitud cero dirtokeep.

El resultado será que todo lo que en dirtokeepserán ignorados, excepto dirtokeep/.keep , que dará como resultado que también el dirtokeepdirectorio será construido sobre clon / salida.

Suponiendo que hay algunos directorios ignorados, ¿por qué no usar "git status node / logs /" que le dirá qué archivos se agregarán? En el directorio tengo un archivo de texto que no es parte de la salida de estado, por ejemplo:

En la sucursal maestra
Su sucursal está actualizada con 'origen / maestro'.
Archivos sin seguimiento:
(use "git add ..." para incluir en lo que se confirmará)

    node/logs/.gitignore 

.gitignore es:

*

! .gitignore