RUTAS Y REGLAS DE GIT

Probador de .gitignorecon decisiones explicadas

Prueba un .gitignore raíz con rutas candidatas. Un / final identifica una carpeta.

Probador de .gitignore

Reglas .gitignore

Rutas candidatas

Las reglas y las rutas se procesan en este navegador. No se lee ni modifica ningún repositorio.

Resultados por ruta

Introduce al menos una ruta.

Convenciones de rutas y alcance

Usa rutas relativas al directorio de este .gitignore y separadores /. Termina las carpetas con /. Se rechazan rutas absolutas, unidades, barras inversas, segmentos vacíos, . y ... Se conservan los espacios.

Un .gitignore raíz; simulación de rutas no rastreadas con comparación de bytes UTF-8 sensible a mayúsculas. Sin reglas anidadas, exclusiones globales, índice ni consulta del disco.

Máximo: 50 líneas físicas de reglas y 200 rutas no vacías; 256 unidades UTF-16 por regla, 512 por ruta y 32 segmentos. Sin caracteres de control. El worker se detiene a los 2 segundos.

Resultados desactualizados o cálculo en curso.

Si una excepción no recupera un archivo, revisa primero sus carpetas superiores. Este Probador de .gitignore identifica el directorio que impide llegar al archivo y muestra qué línea decide el resultado, aunque otra regla posterior nombre exactamente ese archivo.

Los dos campos arrancan con un ejemplo calculado automáticamente. Sustituye las reglas gitignore y las rutas de archivo por un caso pequeño de tu proyecto para distinguir exclusiones, reincorporaciones explícitas y rutas sin regla aplicable.

Qué aclara este Probador de .gitignore

Encontrar la carpeta que bloquea una excepción

build/ excluye la carpeta e impide examinar build/keep.txt, por lo que !build/keep.txt no lo recupera. Con cache/*, cache/ sigue siendo accesible y !cache/keep.txt puede funcionar. El Probador de .gitignore permite localizar ese bloqueo en lugar de dar por válida cualquier negación.

Una carpeta cerrada bloquea a sus hijos; otra abierta permite conservar un archivo mediante una excepción.

Ver el efecto acumulado de las reglas

Una ruta puede quedar excluida, recuperarse y volver a excluirse. El historial recalcula el resultado tras cada línea física, incluidos comentarios y líneas vacías. Compara la línea decisiva entre pasos para saber si cambió la ruta o un directorio superior; no es una lista de coincidencias directas con cada línea nueva.

Un archivo atraviesa tres controles: exclusión, reincorporación y nueva exclusión.

Reproduce el problema con precisión

01

Indica la base y marca las carpetas

Escribe las rutas desde el directorio del .gitignore. build/ representa una carpeta y build un archivo. Un / inicial ancla un patrón, pero no es válido al inicio de una ruta candidata. Los espacios forman parte del nombre y no se recortan para forzar coincidencias.

02

Examina el primer directorio excluido

Despliega el historial de una ruta. Si aparece un directorio superior bloqueado, recupéralo primero o excluye solo sus hijos con un patrón como cache/*. Una excepción de archivo no atraviesa ese bloqueo. La línea decisiva puede ser anterior al paso que estás leyendo.

03

Controla cuándo se recalcula

El modo automático espera 350 ms tras cada edición. Desactívalo para usar Probar reglas o Ctrl/Cmd+Intro. Al editar, el informe queda desactualizado. Ejemplo y Vaciar muestran una vista previa; Deshacer restaura entradas y resultados. Exporta JSON si necesitas conservar los pasos.

Resultados que se pueden revisar

Patrones de Git, con límites claros

El motor ignore 7.0.9 interpreta *, ?, rangos entre corchetes y **. La comparación distingue mayúsculas y trabaja sobre bytes UTF-8: ? cubre un byte, no todo un carácter multibyte. No ofrece expansión de llaves ni un modo adicional de expresiones regulares.

La última regla que decide

Comentarios y líneas vacías mantienen su posición. En cada nodo accesible manda el último patrón coincidente, tanto para excluir como para recuperar. Por eso, dos reglas positivas iguales señalan la última línea que coincide, no únicamente la primera exclusión.

Historial completo o resumen tabular

El JSON conserva las rutas originales, las reglas y todos los estados de prefijo. El TSV resume tipo de ruta, exclusión, línea, patrón y directorio bloqueante. Se exportan todas las rutas, aunque solo se vean 50; las celdas TSV que parecen fórmulas llevan un apóstrofo protector.

Qué entra en esta simulación

Un archivo y rutas no rastreadas
Este Probador de .gitignore evalúa un único archivo raíz. No combina .gitignore anidados, .git/info/exclude, exclusiones globales ni patrones de comandos. Tampoco conoce el índice, los archivos preparados, enlaces simbólicos ni la existencia real de cada ruta.
Entrada literal, sin normalización oculta
Se exige / y un / final en carpetas. No se aceptan rutas absolutas o de Windows, segmentos . o .., caracteres de control ni Unicode mal formado. Se saltan las líneas candidatas vacías; una línea de espacios cuenta como nombre. Escapa # o ! al inicio de una regla si son literales. Los espacios finales sin escapar en las reglas se ignoran.
Presupuesto de cálculo
Hasta 50 líneas físicas de reglas, 200 candidatos no vacíos, 256 unidades UTF-16 por regla, 512 por ruta y 32 segmentos. Un salto final no añade otra regla. El worker termina al superar 2 segundos. Los informes fallidos o desactualizados no se pueden exportar.
La comprobación final corresponde a Git
Se fija la comparación sensible a mayúsculas y se usan las API públicas de ignore. No se simulan todas las configuraciones de Git: confirma el caso con git check-ignore -v en el repositorio. Una regla que no coincide con tus candidatos puede afectar a otros archivos y no debe considerarse inútil por ese motivo. Solo se admite ** como segmento completo; formas como *** o a** quedan fuera del alcance del probador, aunque Git pueda interpretarlas.

Preguntas sobre el Probador de .gitignore

¿Por qué el patrón ! no vuelve a incluir mi archivo?

Si una carpeta superior está excluida, Git no visita sus hijos. Debes recuperar esa carpeta o usar una exclusión de sus contenidos, como build/*, seguida de la excepción del archivo. El Probador de .gitignore muestra el directorio bloqueante y la línea que lo excluyó.

¿En qué se diferencian build y /build?

build puede coincidir con ese nombre a cualquier profundidad. /build lo limita al directorio del .gitignore. Una barra intermedia también hace que el patrón sea relativo a esa base. Compara build y src/build entre las rutas candidatas para observar la diferencia.

¿Una regla logs/ afecta a un archivo común llamado logs?

No: la barra final restringe la regla a directorios. Introduce logs/ para probar una carpeta y logs para un archivo. El navegador no consulta el sistema de archivos ni deduce el tipo de una ruta a partir de las demás.

¿Cómo funcionan las tres variantes de **?

Al principio, **/ permite cualquier profundidad; al final, /** alcanza los descendientes. Entre nombres, a/**/b admite cero o más directorios intermedios. * y ? no atraviesan /. La comparación usa bytes UTF-8, por lo que ? representa un byte y no necesariamente un carácter entero.

¿Por qué Git muestra cambios aunque la regla sea correcta?

Un archivo rastreado sigue en el índice después de añadirlo a .gitignore. Aquí se simulan cadenas como rutas no rastreadas; el resultado no cambia su estado real. Comprueba primero con Git si el archivo ya está bajo control de versiones.

¿Encontraste un caso para revisar?

Comprueba tu próximo cambio de reglas

Usa el Probador de .gitignore con una ruta que deba excluirse y otra que quieras conservar. Incluye el directorio superior si una excepción no funciona.

Guarda el historial para la revisión y confirma el comportamiento en el repositorio real antes de ajustar las reglas.