.gitignore → regex · path tester · live

Convert .gitignore rules into regex

Parse a gitignore file, see each rule's equivalent regex, and test paths against the combined ignore behaviour. Runs locally.

Gitignore to Regex
Rules
6
parsed
Ignored
5
paths
Tracked
2
paths
Negations
1
rules
input · .gitignore + paths
.gitignore
Test paths (one per line)
output · regex + path verdicts
Rules → regex
Type
Rule
Regex
ignore
node_modules/(?:^|/)node_modules(?:/|$)
ignore
dist/(?:^|/)dist(?:/|$)
ignore
*.log(?:^|/)[^/]*\.log(?:/|$)
allow
!important.log(?:^|/)important\.log(?:/|$)
ignore
/build^build(?:/|$)
ignore
src/**/*.tmp^src/(?:.*/)?[^/]*\.tmp(?:/|$)
Path verdicts
IGNOREDnode_modules/foo/index.jsby node_modules/
IGNOREDdist/main.jsby dist/
IGNOREDapp.logby *.log
trackedimportant.logby !important.log
IGNOREDbuild/outby /build
IGNOREDsrc/a/b/test.tmpby src/**/*.tmp
trackedREADME.md
Quick Start

How to convert .gitignore to regex

Parse .gitignore rules, see each rule's equivalent regex, and test paths against the combined ignore behaviour.

  1. 01

    Paste rules

    Comments and blank lines are skipped. Negations (!) and dir-only (/) are preserved.

    Patterns compile through the JavaScript RegExp constructor, so syntax errors surface immediately and engine quirks like Unicode property escapes (\p{L}) work when the u flag is on.

    patternECMAScriptliterallive
    input · literalrules · regex
    node_modules/ *.log
    loaded · ECMAScriptPCRE · ready
  2. 02

    Read regex

    Each rule expands into its equivalent regex (with anchors and dir-only suffixes).

    Each flag character mirrors the ECMAScript literal: g enables iteration, i folds case, m anchors per line, s lets . match newlines, u unlocks proper Unicode, y is sticky, and d emits indices.

    flagsoptionsg · i · mlive
    config · optionsregex · flags
    ^node_modules(?:/|$)
    flags applied · liveECMA · live
  3. 03

    Test paths

    Drop paths to see whether each gets IGNORED or tracked, and by which rule.

    Watch for catastrophic backtracking on nested quantifiers — a common ReDoS source. The tool caps match counts to keep the page responsive on pathological patterns.

    matchgroupshighlightReDoS-safe
    run · outputverify · matches
    IGNORED node_modules/foo/index.js
    matches · livegroups · live
  4. 04

    Copy or export

    Grab the output as JSON, CSV, or plain text — ready for your editor or pipeline.

    Copy writes via navigator.clipboard.writeText; downloads use a Blob and object URL, so nothing transits the network and the output is byte-identical to what you see on screen.

    copyexportclipboardblob
    export · exportedready · saved
    Copied
    ready to shipsuccess
Pro tips

Regex patterns that don't melt down

Use named groups

(?<year>\d{4}) reads better than $1 and survives reordering. Supported in ECMAScript 2018+.

Anchor strictly

Use ^/$ with the m flag when matching whole lines. Without anchors, partial matches sneak through.

Avoid catastrophic backtracking

Nested quantifiers like (a+)+ can explode. Run patterns through ReDoS Detector first.

Escape every literal

Backslash any meta character you want literally: \.\$\^\*\+\?\(\)\[\]\{\}\|\\.

Test edge cases

Empty string, single character, unicode, the maximum length you expect — write fixtures for each.

Patterns aren&rsquo;t parsers

Don’t parse HTML, JSON, or balanced parens with regex. Use a proper parser when the grammar is recursive.

Use Cases

When to inspect .gitignore

Audit, teach, and port ignore rules confidently.

Audit your gitignore

Confirm node_modules is actually ignored. Compiles through the JavaScript RegExp constructor — engine quirks (Unicode property escapes, sticky matching, named groups) work when their flags are on. Error messages cite the exact position of any syntax issue.

ReDoS-safe

Build dotfiles

Sanity-check before committing a new ignore set. Pairs with the ReDoS detector to catch catastrophic backtracking before you deploy. A pattern that handles 1k-character input fine can become a denial-of-service vector on attacker-controlled 1M-character input.

ECMA-compliant

Port to .dockerignore

Compare semantics across ignore files. Output exports as JavaScript, Python re, Java util.regex, .NET System.Text.RegularExpressions, PCRE, and POSIX — language quirks are highlighted on conversion so you don't ship a JS-only pattern to a Go service.

spec-grade

Teach gitignore

Show how rules compose with negation. Capture groups (named or numbered) round-trip cleanly into replacement strings, JSON output, or CSV extraction without re-typing. Backreferences ($1, ${name}) preserve semantics across languages.

cross-engine

Catch overrides

See which rule wins for a path. Test against edge cases — empty input, single character, max length, multibyte boundaries — to catch off-by-one and zero-length match bugs before they reach production.

test-ready

Programmatic use

Lift the regex into a script that mimics gitignore. All matching runs client-side so secret patterns never leave the browser. Useful when the pattern itself is sensitive (PII regexes, internal data formats, security filters).

production-ready
FAQ

Frequently asked questions

Close but not identical — git's matcher has edge cases (re-includes inside ignored dirs) this regex view doesn't model.
Yes — lines starting with ! are allow rules. The last matching rule wins.
It anchors non-rooted rules at the start of the path or after a directory separator — same as git's behaviour.
Trailing / marks dir-only — modelled here with the (?:/|$) suffix.
No. The tool runs entirely in your browser — your pattern and sample text never leave the page.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!