Skip to main content

How to Resolve the "SyntaxError: Invalid regular expression: Nothing to repeat" Error

The SyntaxError: Invalid regular expression: ... Nothing to repeat is a common error in JavaScript that occurs when you incorrectly use a quantifier in a regular expression. Quantifiers like *, +, and ? are used to specify how many times a character or group should appear, and they must always follow the item they are modifying.

This guide will explain the fundamental reason this error happens and walk you through the most common mistakes that cause it, such as unescaped special characters or misplaced quantifiers.

The Core Problem: Quantifiers Need Something to Repeat​

In a regular expression, characters like * (zero or more times), + (one or more times), and ? (zero or one time) are called quantifiers. Their job is to modify the character, group, or character class that comes immediately before them.

The "Nothing to repeat" error occurs when you place a quantifier in a position where there is no preceding item for it to modify.

Example of problem:

// This is invalid because the `+` has nothing before it to quantify.
let regex = /+abc/; // SyntaxError: Invalid regular expression: /+abc/: Nothing to repeat

// This is also invalid because the `*` has nothing before it.
let regex2 = /*abc/; // SyntaxError

Cause 1 (Most Common): An Unescaped Special Character​

This is the most frequent cause of the error. You write a regex that includes a special character like + or *, intending to match it as a literal character, but you forget to escape it with a backslash (\).

Example of problem:

// Problem: We want to match the literal string "C++".
let language = 'C++';

// This regex is invalid because the second `+` is a quantifier with nothing before it.
// The engine sees it as `C` followed by `+` (quantifier) followed by another `+` (quantifier).
let regex = /C++/;

Error Output:

Uncaught SyntaxError: Invalid regular expression: /C++/: Nothing to repeat

Solution: to match a special character as a literal, you must escape it with a backslash.

let language = 'C++';

// Correct: Escape the `+` characters to treat them as literals.
let regex = /C\+\+/;

if (language.match(regex)) {
  console.log('Found a match!'); // Output: Found a match!
}

Common Special Characters That Need Escaping: *, +, ?, ., (, ), [, ], {, }, ^, $, |, \

Cause 2: A Misplaced Quantifier​

The error also occurs if you accidentally place a quantifier at the beginning of your regex or a group, where it has no preceding character to act upon.

Example of problem: both of these will throw the "Nothing to repeat" error.

// Problem: The quantifier `+` is at the beginning of the regex.
let regex = /+123/;     // Invalid

// Problem: The quantifier `*` is at the beginning of a group.
let regex2 = /(*abc)/;  // Invalid

Solution: ensure your quantifier always follows the character or group it is meant to quantify.

// Correct: The `+` now modifies the `\d` (digit) character.
// This matches one or more digits.
let regex = /\d+/;

// Correct: The `*` now modifies the `c` character.
// This matches "ab" followed by zero or more "c"s.
let regex2 = /abc*/;
note

If you intended to match a literal + or * at the beginning of the string, you must escape it.

let text = '+123';

// Correct: Escape the `+` to match it literally.
let regex = /\+123/;
console.log(text.match(regex)); // Output: [ '+123', ... ]

How to Debug the Error​

  • Check Your Quantifiers: The first thing to look for is a *, +, or ? that is at the very beginning of your regex or immediately following another quantifier (like ?*).
  • Escape Special Characters: Carefully review your regex for any of the special characters listed above. If you mean to match them literally, make sure they are escaped with a \.
  • Use an Online Regex Tester: Tools like regex101.com are invaluable. They provide an instant analysis of your regular expression, highlight syntax errors, and give you a clear explanation of what each part of your pattern does.

Conclusion​

The SyntaxError: Invalid regular expression: Nothing to repeat is always caused by an improper use of a quantifier (*, +, ?).

To solve it:

  • Ensure that every quantifier follows the character, character set, or group it is intended to modify.
  • If you need to match a special character like + or * as a literal character, you must escape it with a backslash (e.g., \+, \*).

By correctly placing and escaping your quantifiers, you can easily resolve this common regular expression error.

Table of Contents