Git
Ignorando archivos y carpetas

Introducción

Ignorando archivos y directorios con un archivo .gitignore

Puede hacer que Git ignore ciertos archivos y directorios, es decir, excluirlos de que Git los .gitignore , mediante la creación de uno o más archivos .gitignore en su repositorio.

En los proyectos de software, .gitignore generalmente contiene una lista de archivos y / o directorios que se generan durante el proceso de compilación o en tiempo de ejecución. Las entradas en el archivo .gitignore pueden incluir nombres o rutas que apuntan a:

1. recursos temporales, por ejemplo, cachés, archivos de registro, código compilado, etc.
2. Archivos de configuración local que no deben compartirse con otros desarrolladores.
3. archivos que contienen información secreta, como contraseñas de inicio de sesión, claves y credenciales

Cuando se crean en el directorio de nivel superior, las reglas se aplicarán recursivamente a todos los archivos y subdirectorios en todo el repositorio. Cuando se crean en un subdirectorio, las reglas se aplicarán a ese directorio específico y sus subdirectorios.

Cuando se ignora un archivo o directorio, no será:

1. seguido por Git
2. reportado por comandos como git status o git diff
3. puesta en escena con comandos como git add -A

En el caso inusual de que necesite ignorar los archivos rastreados, se debe tener especial cuidado. Ver: Ignorar los archivos que ya se han confirmado en un repositorio Git .

Ejemplos

Aquí hay algunos ejemplos genéricos de reglas en un archivo .gitignore , basados ​​en patrones de archivos glob :

# Lines starting with `#` are comments.

# Ignore files called 'file.ext'
file.ext

# Comments can't be on the same line as rules!
# The following line ignores files called 'file.ext # not a comment'
file.ext # not a comment 

# Ignoring files with full path.
# This matches files in the root directory and subdirectories too.
# i.e. otherfile.ext will be ignored anywhere on the tree.
dir/otherdir/file.ext
otherfile.ext

# Ignoring directories
# Both the directory itself and its contents will be ignored.
bin/
gen/

# Glob pattern can also be used here to ignore paths with certain characters.
# For example, the below rule will match both build/ and Build/
[bB]uild/

# Without the trailing slash, the rule will match a file and/or
# a directory, so the following would ignore both a file named `gen`
# and a directory named `gen`, as well as any contents of that directory
bin
gen

# Ignoring files by extension
# All files with these extensions will be ignored in
# this directory and all its sub-directories.
*.apk
*.class

# It's possible to combine both forms to ignore files with certain
# extensions in certain directories. The following rules would be
# redundant with generic rules defined above.
java/*.apk
gen/*.class

# To ignore files only at the top level directory, but not in its
# subdirectories, prefix the rule with a `/`
/*.apk
/*.class

# To ignore any directories named DirectoryA 
# in any depth use ** before DirectoryA
# Do not forget the last /, 
# Otherwise it will ignore all files named DirectoryA, rather than directories
**/DirectoryA/
# This would ignore 
# DirectoryA/
# DirectoryB/DirectoryA/ 
# DirectoryC/DirectoryB/DirectoryA/
# It would not ignore a file named DirectoryA, at any level

# To ignore any directory named DirectoryB within a 
# directory named DirectoryA with any number of 
# directories in between, use ** between the directories
DirectoryA/**/DirectoryB/
# This would ignore 
# DirectoryA/DirectoryB/ 
# DirectoryA/DirectoryQ/DirectoryB/ 
# DirectoryA/DirectoryQ/DirectoryW/DirectoryB/

# To ignore a set of files, wildcards can be used, as can be seen above.
# A sole '*' will ignore everything in your folder, including your .gitignore file.
# To exclude specific files when using wildcards, negate them.
# So they are excluded from the ignore list:
!.gitignore 

# Use the backslash as escape character to ignore files with a hash (#)
# (supported since 1.6.2.1)
\#*#

La .gitignore archivos .gitignore son estándar en varios idiomas, así que para comenzar, aquí hay un conjunto de archivos .gitignore de muestra enumerados por idioma desde el cual se clonan, copian o modifican en su proyecto. Alternativamente, para un proyecto nuevo, puede considerar la generación automática de un archivo de inicio utilizando una herramienta en línea .

Otras formas de .gitignore

.gitignore archivos .gitignore están destinados a comprometerse como parte del repositorio. Si desea ignorar ciertos archivos sin confirmar las reglas de ignorar, aquí hay algunas opciones:

• Edite el archivo .git/info/exclude (con la misma sintaxis que .gitignore ). Las reglas serán globales en el alcance del repositorio;
• Configure un archivo gitignore global que aplicará reglas de ignorar a todos sus repositorios locales:

Además, puede ignorar los cambios locales a los archivos rastreados sin cambiar la configuración global de git con:

• git update-index --skip-worktree [<file>...] : para modificaciones locales menores
• git update-index --assume-unchanged [<file>...] : para archivos listos para producción, no cambiantes en sentido ascendente

Vea más detalles sobre las diferencias entre los últimos indicadores y la documentación del git update-index para obtener más opciones.

Limpiando archivos ignorados

Puedes usar git clean -X para limpiar archivos ignorados:

git clean -Xn #display a list of ignored files
git clean -Xf #remove the previously displayed files

Nota: -X (mayúsculas) limpia solo los archivos ignorados. Utilice -x (sin mayúsculas) para eliminar también los archivos sin seguimiento.

Vea la documentación de git clean para más detalles.

Consulte el manual de Git para más detalles.

Excepciones en un archivo .gitignore

Si ignora los archivos utilizando un patrón pero tiene excepciones, prefija un signo de exclamación (!) A la excepción. Por ejemplo:

*.txt
!important.txt

El ejemplo anterior le indica a Git que ignore todos los archivos con la extensión .txt excepto los archivos llamados important.txt .

Si el archivo está en una carpeta ignorada, NO puede volver a incluirlo tan fácilmente:

folder/
!folder/*.txt

En este ejemplo, todos los archivos .txt en la carpeta permanecerán ignorados.

La forma correcta es volver a incluir la carpeta en una línea separada, luego ignorar todos los archivos en la folder con * , finalmente, volver a incluir el *.txt en la folder , como se *.txt a continuación:

!folder/
folder/*
!folder/*.txt

Nota : para los nombres de archivos que comienzan con un signo de exclamación, agregue dos signos de exclamación o escape con el carácter \ :

!!includethis
\!excludethis

Un archivo .gitignore global

Para que Git ignore ciertos archivos en todos los repositorios, puede crear un .gitignore global con el siguiente comando en su terminal o símbolo del sistema:

$ git config --global core.excludesfile <Path_To_Global_gitignore_file>

Git ahora usará esto además del propio archivo .gitignore de cada repositorio. Las reglas para esto son:

• Si el archivo .gitignore local incluye explícitamente un archivo, mientras que el .gitignore global .gitignore ignora, el .gitignore local tiene prioridad (el archivo se incluirá)
• Si el repositorio se clona en varias máquinas, entonces .gigignore global debe cargarse en todas las máquinas o al menos incluirlo, ya que los archivos ignorados se enviarán al repositorio mientras que la PC con el .gitignore global no lo actualizaría. . Esta es la razón por la que un .gitignore específico del .gitignore es una mejor idea que uno global si un equipo trabaja en el proyecto.

Este archivo es un buen lugar para mantener ignorados específicos de plataformas, máquinas o usuarios, por ejemplo, OSX .DS_Store , Windows Thumbs.db o Vim *.ext~ y *.ext.swp ignoran si no desea mantenerlos en el repositorio . Por lo tanto, un miembro del equipo que trabaja en OS X puede agregar todos los .DS_STORE y _MACOSX (que en realidad es inútil), mientras que otro miembro del equipo en Windows puede ignorar todos los thumbs.bd

Ignorar los archivos que ya se han confirmado en un repositorio Git

Si ya ha agregado un archivo a su repositorio Git y ahora desea dejar de rastrearlo (para que no esté presente en futuras confirmaciones), puede eliminarlo del índice:

git rm --cached <file>

Esto eliminará el archivo del repositorio e impedirá que Git rastree otros cambios. La opción --cached asegurará que el archivo no se elimine físicamente.

Tenga en cuenta que los contenidos agregados previamente del archivo aún serán visibles a través del historial de Git.

Tenga en cuenta que si alguien más extrae del repositorio después de haber eliminado el archivo del índice, su copia se eliminará físicamente .

Puede hacer que Git pretenda que la versión de directorio de trabajo del archivo está actualizada y leer la versión de índice en su lugar (ignorando así los cambios en ella) con el bit " omitir worktree "

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

La escritura no se ve afectada por este bit, la seguridad del contenido sigue siendo la primera prioridad. Nunca perderás tus preciosos cambios ignorados; por otro lado, este bit entra en conflicto con el ocultamiento: para eliminar este bit, use

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

A veces se recomienda erróneamente mentirle a Git y hacer que asuma que el archivo no se modifica sin examinarlo. A primera vista, considera que ignora cualquier cambio adicional en el archivo, sin eliminarlo de su índice:

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

Esto forzará a git a ignorar cualquier cambio realizado en el archivo (tenga en cuenta que si extrae cualquier cambio en este archivo, o si lo guarda, sus cambios ignorados se perderán )

Si desea que git vuelva a "preocuparse" por este archivo, ejecute el siguiente comando:

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

Comprobando si un archivo es ignorado

El comando git check-ignore informa sobre los archivos ignorados por Git.

Puede pasar los nombres de archivo en la línea de comandos, y git check-ignore mostrará los nombres de archivos que se ignoran. Por ejemplo:

$ cat .gitignore
*.o
$ git check-ignore example.o Readme.md
example.o

Aquí, solo los archivos * .o están definidos en .gitignore, por lo que Readme.md no aparece en la salida de git check-ignore .

Si desea ver la línea de la que .gitignore es responsable de ignorar un archivo, agregue -v al comando git check-ignore:

$ git check-ignore -v example.o Readme.md
.gitignore:1:*.o        example.o

Desde Git 1.7.6 en adelante, también puede usar git status --ignored para ver archivos ignorados. Puede encontrar más información sobre esto en la documentación oficial o en Buscar archivos ignorados por .gitignore .

Ignorar archivos en subcarpetas (múltiples archivos gitignore)

Supongamos que tienes una estructura de repositorio como esta:

examples/
    output.log
src/
    <files not shown>
    output.log
README.md

output.log en el directorio de ejemplos es válido y es necesario para que el proyecto reúna un entendimiento, mientras que el que está debajo de src/ se crea durante la depuración y no debe estar en el historial o parte del repositorio.

Hay dos formas de ignorar este archivo. Puede colocar una ruta absoluta en el archivo .gitignore en la raíz del directorio de trabajo:

# /.gitignore
src/output.log

Alternativamente, puede crear un archivo .gitignore en el directorio src/ e ignorar el archivo relativo a este .gitignore :

# /src/.gitignore
output.log

Ignorando un archivo en cualquier directorio

Para ignorar un archivo foo.txt en cualquier directorio, solo debe escribir su nombre:

foo.txt # matches all files 'foo.txt' in any directory

Si desea ignorar el archivo solo en parte del árbol, puede especificar los subdirectorios de un directorio específico con ** patrón:

bar/**/foo.txt # matches all files 'foo.txt' in 'bar' and all subdirectories

O puede crear un archivo .gitignore en la bar/ directorio. Equivalente al ejemplo anterior sería crear la bar/.gitignore archivos bar/.gitignore con estos contenidos:

foo.txt # matches all files 'foo.txt' in any directory under bar/

Ignorar archivos localmente sin cometer reglas de ignorar

.gitignore ignora los archivos localmente, pero está destinado a comprometerse con el repositorio y compartirse con otros contribuyentes y usuarios. Puede establecer un .gitignore global, pero luego todos sus repositorios compartirían esa configuración.

Si desea ignorar ciertos archivos en un repositorio localmente y no hacer que el archivo sea parte de ningún repositorio, edite .git/info/exclude dentro de su repositorio.

Por ejemplo:

# these files are only ignored on this repo
# these rules are not shared with anyone
# as they are personal                                              
gtk_tests.py
gui/gtk/tests/*
localhost
pushReports.py
server/

Plantillas precargadas .gitignore

Si no está seguro de qué reglas incluir en su archivo .gitignore , o simplemente desea agregar excepciones generalmente aceptadas a su proyecto, puede elegir o generar un archivo .gitignore :

• https://www.toptal.com/developers/gitignore
• https://github.com/github/gitignore

Muchos servicios de alojamiento como GitHub y BitBucket ofrecen la capacidad de generar archivos .gitignore basados ​​en los lenguajes de programación e IDE que puede estar usando:

Ignorar los cambios posteriores en un archivo (sin eliminarlo)

A veces desea mantener un archivo en Git pero ignorar los cambios posteriores.

Dígale a Git que ignore los cambios en un archivo o directorio usando update-index :

git update-index --assume-unchanged my-file.txt

El comando anterior le indica a Git que asuma que my-file.txt no se ha modificado, y que no debe verificar o informar cambios. El archivo todavía está presente en el repositorio.

Esto puede ser útil para proporcionar valores predeterminados y permitir anulaciones del entorno local, por ejemplo:

# create a file with some values in
cat <<EOF
MYSQL_USER=app
MYSQL_PASSWORD=FIXME_SECRET_PASSWORD
EOF > .env

# commit to Git
git add .env
git commit -m "Adding .env template"

# ignore future changes to .env
git update-index --assume-unchanged .env

# update your password
vi .env

# no changes!
git status

Ignorando solo parte de un archivo [stub]

A veces, es posible que desee tener cambios locales en un archivo que no desea confirmar o publicar. Lo ideal es que la configuración local se concentre en un archivo separado que pueda ubicarse en .gitignore , pero a veces, como solución a corto plazo, puede ser útil tener algo local en un archivo registrado.

Puedes hacer que Git "no vea" esas líneas usando un filtro limpio. Ni siquiera aparecerán en diferencias.

Supongamos que aquí hay un fragmento del archivo file1.c :

struct settings s;
s.host = "localhost";
s.port = 5653;
s.auth = 1;
s.port = 15653; // NOCOMMIT
s.debug = 1; // NOCOMMIT
s.auth = 0; // NOCOMMIT

No quieres publicar líneas de NOCOMMIT ningún lugar.

Cree un filtro "nocommit" agregando esto al archivo de configuración de Git como .git/config :

[filter "nocommit"]
    clean=grep -v NOCOMMIT

Agregue (o cree) esto a .git/info/attributes o .gitmodules :

file1.c filter=nocommit

Y tus líneas NOCOMMIT están ocultas de Git.

Advertencias:

• El uso de un filtro limpio ralentiza el procesamiento de archivos, especialmente en Windows.
• La línea ignorada puede desaparecer del archivo cuando Git lo actualiza. Puede contrarrestarse con un filtro de manchas, pero es más complicado.
• No probado en Windows

Ignorando los cambios en los archivos rastreados. [talón]

.gitignore y .git/info/exclude funcionan solo para archivos sin seguimiento.

Para establecer el indicador de ignorar en un archivo seguido, use el comando update-index :

git update-index --skip-worktree myfile.c

Para revertir esto, usa:

git update-index --no-skip-worktree myfile.c

Puede agregar este fragmento de código a su configuración global de git para tener comandos de git hide , git unhide y git hidden más convenientes:

[alias]
    hide   = update-index --skip-worktree
    unhide = update-index --no-skip-worktree
    hidden  = "!git ls-files -v | grep ^[hsS] | cut -c 3-"

También puede usar la opción --asumir-sin cambios con la función de actualización del índice

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

Si desea ver este archivo nuevamente para los cambios, use

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

Cuando se especifica el indicador "asume-unchanged", el usuario se compromete a no cambiar el archivo y le permite a Git asumir que el archivo del árbol de trabajo coincide con lo que se registra en el índice. por ejemplo, cuando se fusiona en un compromiso; por lo tanto, en caso de que el archivo supuestamente sin seguimiento se modifique en sentido ascendente, deberá manejar la situación manualmente. En este caso, la atención se centra en el rendimiento.

Si bien el indicador --skip-worktree es útil cuando le indica a git que no toque un archivo específico porque el archivo se cambiará localmente y no quiere cometer los cambios accidentalmente (es decir, el archivo de configuración / propiedades configurado para un determinado ambiente). Skip-worktree tiene prioridad sobre asumir-sin cambiar cuando ambos están configurados.

Borrar archivos ya confirmados, pero incluidos en .gitignore

A veces sucede que git rastreaba un archivo, pero en un momento posterior se agregó a .gitignore para dejar de rastrearlo. Es un escenario muy común olvidarse de limpiar estos archivos antes de agregarlos a .gitignore. En este caso, el archivo antiguo aún estará en el repositorio.

Para solucionar este problema, uno podría realizar una eliminación "en seco" de todo en el repositorio, seguido de volver a agregar todos los archivos. Mientras no tenga cambios pendientes y se --cached parámetro --cached , este comando es bastante seguro de ejecutar:

# Remove everything from the index (the files will stay in the file system) 
$ git rm -r --cached .

# Re-add everything (they'll be added in the current state, changes included)
$ git add .

# Commit, if anything changed. You should see only deletions
$ git commit -m 'Remove all files that are in the .gitignore'

# Update the remote
$ git push origin master

Crear una carpeta vacía

No es posible agregar y confirmar una carpeta vacía en Git debido a que Git administra los archivos y adjunta su directorio a ellos, lo que reduce las confirmaciones y mejora la velocidad. Para solucionar esto, hay dos métodos:

Método uno: .gitkeep

Un truco para .gitkeep esto es usar un archivo .gitkeep para registrar la carpeta de Git. Para hacer esto, simplemente cree el directorio requerido y agregue un archivo .gitkeep a la carpeta. Este archivo está en blanco y no sirve para otro propósito que no sea simplemente registrar la carpeta. Para hacer esto en Windows (que tiene extrañas convenciones de nomenclatura de archivos) simplemente abra git bash en el directorio y ejecute el comando:

$ touch .gitkeep

Este comando solo .gitkeep archivo .gitkeep en blanco en el directorio actual

Método dos: dummy.txt

Otro truco para esto es muy similar al anterior y se pueden seguir los mismos pasos, pero en lugar de un .gitkeep , solo usa un dummy.txt en dummy.txt lugar. Esto tiene la ventaja adicional de poder crearlo fácilmente en Windows usando el menú contextual. Y también puedes dejar mensajes graciosos en ellos. También puedes usar el archivo .gitkeep para rastrear el directorio vacío. .gitkeep normalmente es un archivo vacío que se agrega para rastrear el directoy vacío.

Buscando archivos ignorados por .gitignore

Puede listar todos los archivos ignorados por git en el directorio actual con el comando:

git status --ignored

Así que si tenemos una estructura de repositorio como esta:

.git
.gitignore
./example_1
./dir/example_2
./example_2

... y .gitignore archivo que contiene:

example_2

... que el resultado del comando será:

$ git status --ignored

On branch master

Initial commit

Untracked files:
  (use "git add <file>..." to include in what will be committed)

.gitignore
.example_1

Ignored files:
  (use "git add -f <file>..." to include in what will be committed)

dir/
example_2

Si desea enumerar los archivos ignorados recursivamente en los directorios, tiene que usar un parámetro adicional - --untracked-files=all

El resultado se verá así:

$ git status --ignored --untracked-files=all
On branch master

Initial commit

Untracked files:
  (use "git add <file>..." to include in what will be committed)

.gitignore
example_1

Ignored files:
  (use "git add -f <file>..." to include in what will be committed)

dir/example_2
example_2