Elysia Tools
Navigation
Development
Detect error-prone and risky regex patterns, check for catastrophic backtracking, unanchored patterns, and provide rewrite suggestions
Details
Regex Linter analyzes regular expressions for common anti-patterns, performance issues, and correctness problems. It helps you write better, safer, and more efficient regular expressions.
(a+)+ that can cause exponential time complexity(.*)* that exhibit O(n²) performance. when you mean . (literal dot)[a-Z] that include unexpected characters escapes in modern regex.*? patterns that could use negated character classes\-[^[^]] patternsa|ab where order matters(?:...) when groups aren't referencedddd to d{3}Input:
(.*+)a
Output:
{
"summary": {
"score": 50,
"severity": "error",
"issuesFound": 2
},
"issues": [
{
"severity": "critical",
"message": "Catastrophic backtracking risk",
"suggestion": {
"pattern": "[^a]*a",
"explanation": "Use negated character class instead"
}
}
]
}
Execution
Fill in the form, run the tool, and review the result in one place.
Samples
Related
Ready for a run
Tool usage guide
The Regex Linter analyzes regular expressions for common anti-patterns, performance issues, and correctness problems. It helps you write safer, more efficient regex by detecting issues like catastrophic backtracking and providing rewrite suggestions.
Background
A developer is writing a regex to match strings ending with 'a'.
Problem
The pattern `(.*+)a` uses a possessive quantifier that can cause catastrophic backtracking.
How to use
Enter the regex pattern `(.*+)a` in the input field, select JavaScript as the dialect, and set check level to standard.
Outcome
The tool flags the pattern as critical for catastrophic backtracking and suggests using a negated character class like `[^a]*a`.
Background
A user is writing a regex to match file paths with literal dots.
Problem
Using `.` instead of `\.` for literal dots can lead to incorrect matches across any character.
How to use
Input the pattern, set target dialect to PCRE, and check level to standard to catch unescaped characters.
Outcome
The tool detects unescaped dots and suggests escaping them as `\.` for accurate literal matching.
It's a situation where nested quantifiers in a regex can cause exponential time complexity, leading to performance issues or denial-of-service.
The tool supports JavaScript, Python, PCRE, Go (RE2), and Java, with dialect-specific warnings.
Basic checks only critical performance issues, standard includes errors and warnings, and strict adds style suggestions.
Yes, enable the 'Include Rewrite Suggestions' option to receive optimized pattern alternatives.
Absolutely, it helps identify common mistakes and learn best practices in regex writing.