The + quantifier repeats the previous token one or more times. It is one of the most common tools in regex: turn a single digit \d into a full number \d+, or a letter into a whole word with \w+. Master + and you can match runs of characters efficiently.
One or more
Same meaning
Max match
Lazy mode
Group repeat
All runs
A single metacharacter like \d matches exactly one digit. Real data often contains runs of characters: phone numbers, prices, words, and repeated punctuation. The + quantifier solves this by saying “match the previous item again and again, at least once.”
For example, /\d+/ on "item42" matches "42", not just "4". Without +, you would need to write longer patterns or loop in JavaScript. With +, one concise regex captures the entire number token.
+ QuantifierPlace + immediately after a character, metacharacter, class, or group. It is greedy by default: the engine takes as many repetitions as possible while still allowing the rest of the pattern to succeed.
"a1b22c333".match(/\d+/g);
// ["1", "22", "333"]
"a".match(/a+/); // ["a"]
"".match(/a+/); // null — + requires at least oneShorthand: + equals {1,} (minimum one, no maximum). Unlike *, which allows zero matches, + fails when the preceding token is absent.
Add the global g flag when you want every run in a string, not just the first. "a1b22".match(/\d+/) returns only ["1"]; add g to get ["1", "22"].
+ QuantifierAttach + to tokens you want to repeat, combine with anchors for validation, or use lazy +? for minimal matches:
/\d+/g; // all digit runs
/\w+/g; // all word runs
/\s+/g; // whitespace blocks
/(ha)+/g; // ha, haha, hahaha
/<.+?>/g; // lazy tag match
/^\d+$/; // whole string is digitsUse test() for presence checks, match() to extract runs, and replace(/\s+/g, " ") to collapse repeated spaces.
token+ // one or more of token
\d+ // one or more digits
\w+ // one or more word chars
(group)+ // repeat entire group
token+? // lazy — as few as possible
token{1,} // equivalent to +/\d+/g — extract all number tokens from text./\w+/g — pull words from a sentence./\s+/g — find whitespace runs for splitting or cleanup./^\d+$/ — validate a string contains only digits./(https?:\/\/\S+)/g — capture URL-like runs.| Goal | Pattern / API |
|---|---|
| One or more digits | \d+ |
| One or more words chars | \w+ |
| All runs in string | /pattern+/g |
| Repeat a group | (ab)+ |
| Lazy (minimal) match | +? |
| Longhand form | {1,} |
+ vs * vs ?The three basic repetition quantifiers and when to use each.
token+One or more — requires at least one
token*Zero or more — optional repetition
token?Zero or one — makes token optional
/a+/Fails — + needs at least one a
Open DevTools Console (F12) or use Try-it links. Examples cover digit runs, word extraction, whitespace cleanup, greedy vs lazy matching, and repeating groups.
Match runs of characters with +.
\d+Find every sequence of one or more digits.
const text = "order 12 items for $49.99";
console.log(text.match(/\d+/)); // ["12"] — first run only
console.log(text.match(/\d+/g)); // ["12", "49", "99"]\d+ greedily consumes consecutive digits. The dot in 49.99 breaks the run, so you get separate matches 49 and 99. See also the \d metacharacter page.
Words, whitespace, and advanced repetition.
\w+Pull word-like tokens from a sentence.
const sentence = "Hello, regex world!";
const words = sentence.match(/\w+/g);
console.log(words); // ["Hello", "regex", "world"]\w matches letters, digits, and underscore. The + groups consecutive word characters into tokens. Punctuation and spaces break the runs.
\s+Replace multiple spaces or tabs with a single space.
const messy = "too many spaces";
const clean = messy.replace(/\s+/g, " ");
console.log(clean); // "too many spaces"\s+ matches one or more whitespace characters as a single unit. Replacing each run with one space normalizes the string without manual loops.
+ vs Lazy +?See how greediness affects tag-like matching.
const html = "<b>bold</b> and <i>italic</i>";
console.log(html.match(/<.+>/g));
// ["<b>bold</b> and <i>italic</i>"] — greedy spans too far
console.log(html.match(/<.+?>/g));
// ["<b>", "</b>", "<i>", "</i>"]Greedy + takes as much as possible, so .+ runs from the first < to the last >. Lazy +? stops at the earliest valid point, matching each tag separately.
(ha)+Apply + to a captured group for repeated sequences.
const laughs = ["ha", "haha", "hahaha", "ho"];
laughs.forEach((s) => {
console.log(s, /(ha)+/.test(s));
});
// ha true
// haha true
// hahaha true
// ho false(ha)+ repeats the entire group one or more times. "hahaha" is three ha units. "ho" does not start with ha, so the test fails.
\d+.\w+ and g.\s+.\S+ for tokens./^[a-z]+$/i for letter-only fields.+.+ fails when the preceding token is missing; use * if zero is allowed.+ may match more than you expect; try +? for minimal runs.g, match() returns only the first run.ab+ repeats only b; use (ab)+ to repeat both letters.(a+)+ on hostile input.\d+ alone does not match 49.99 as one token; use \d+\.\d+.+ Quantifier WorksThe engine matches the preceding item once—the minimum for +.
While the next character still matches the token, keep consuming it.
When the next character fails, the quantifier stops and later pattern parts continue.
If the rest of the pattern fails, the engine may give back characters and retry shorter runs.
The + quantifier is part of core JavaScript regular expression syntax.
Supported in every browser and Node.js version. Use + for one-or-more repetition of any token or group.
Bottom line: Safe everywhere. + is the standard way to match runs of one or more characters.
The + quantifier matches one or more of the previous token—turning single-character patterns into powerful run matchers like \d+, \w+, and \s+. It is greedy by default, equivalent to {1,}, and essential for extraction and validation.
Remember to add g for all matches, use +? when greedy matching goes too far, and wrap groups in parentheses when the whole group should repeat. Next, learn (?=...) positive lookahead.
+ when at least one repetition is requiredg to collect every run in a string(group)+ when the whole sequence repeats+? for minimal matching in nested text\d+ over manual digit loops in JavaScript+ when zero matches should succeed—use *ab+ is not the same as (ab)++ match equals the whole string without anchors\d+ alone—add \.\d++ quantifierMatch one or more repetitions with confidence.
One or more.
SyntaxSame rule.
ShorthandMax first.
DefaultMinimal run.
LazyAll runs.
ExtractThe + quantifier is so common that many developers learn \d+ before they learn what \d alone does. Under the hood, + always applies to exactly one preceding token—parentheses let you treat a group as that single token for repetition.
Learn how to require specific following text without consuming it.
6 people found this page helpful