JavaScript RegExp ? Quantifier

What You’ll Learn

The ? quantifier makes the previous token optional—it matches zero or one time. Use it for optional letters (https?), optional signs (-?\d+), optional prefixes, and flexible patterns without writing two separate regexes.

Introduction

Real text is messy: URLs may use http or https, numbers may have an optional minus sign, and names may include an optional title. The ? quantifier handles all of these with one pattern by saying “this part may appear once, or not at all.”

Do not confuse ? the quantifier with ? in lookaheads like (?=...) or (?!...). When ? follows a character or group, it controls repetition. When it immediately follows ( at the start of a special construct, it begins a lookahead assertion—a different feature entirely.

Understanding the ? Quantifier

Place ? right after a token. The engine tries to match that token once; if that helps the overall pattern, it uses it. Otherwise it skips it (zero times) and continues. Both outcomes are valid.

const urls = ["http://a.com", "https://b.com", "ftp://c.com"];

urls.forEach((url) => {
  console.log(url, /^https?/.test(url));
});
// http://a.com   true
// https://b.com  true
// ftp://c.com    false

In https?, the ? applies only to s—so s is optional. The pattern matches http and https but not ftp.

How to Use the ? Quantifier

Attach ? to single characters, escaped literals, or grouped sequences:

/https?/;                 // http or https
/-?\d+/;                  // optional minus on numbers
/colou?r/;                // color or colour
/(Mr\. )?Smith/;         // optional title
/(www\.)?example\.com/; // optional www.

"colour".match(/colou?r/); // ["colour"]

Combine with anchors for validation, or with the global flag to find every optional match in a string. Use ?? for the lazy form (prefer skipping when possible).

📝 Syntax

token?           // zero or one of token
https?           // s is optional
(group)?         // entire group optional
token{0,1}       // equivalent to ?
token??          // lazy — prefer zero

Common patterns

• /https?/ — match http or https.
• /-?\d+/ — integers with optional leading minus.
• /colou?r/ — American or British spelling.
• /(www\.)?example\.com/ — domain with optional www..
• /\.jpe?g$/i — .jpg or .jpeg extension.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover optional protocol letters, spelling variants, signed numbers, optional groups, and file extensions.

const urls = ["http://site.com", "https://secure.com", "ftp://files.com"];

urls.forEach((url) => {
  console.log(url, /^https?/.test(url));
});
// http://site.com    true
// https://secure.com true
// ftp://files.com    false

http://site.com true
https://secure.com true
ftp://files.com false

const words = ["color", "colour", "coloor"];

words.forEach((w) => {
  console.log(w, /colou?r/.test(w));
});
// color  true
// colour true
// coloor false

color true
colour true
coloor false

const values = ["42", "-7", "abc", "3.14"];

values.forEach((v) => {
  console.log(v, /^-?\d+$/.test(v));
});
// 42   true
// -7   true
// abc  false
// 3.14 false

42 true
-7 true
abc false
3.14 false

const names = ["Smith", "Mr. Smith", "Mrs. Smith"];

names.forEach((n) => {
  console.log(n, /^(Mr\. )?Smith$/.test(n));
});
// Smith       true
// Mr. Smith   true
// Mrs. Smith  false

Smith true
Mr. Smith true
Mrs. Smith false

const isJpeg = /\.jpe?g$/i;

console.log(isJpeg.test("photo.jpg"));   // true
console.log(isJpeg.test("photo.jpeg"));  // true
console.log(isJpeg.test("photo.png"));   // false

true
true
false

🚀 Common Use Cases

• URL protocols — https? for http and https.
• Signed numbers — -?\d+ for optional negative values.
• Spelling variants — optional letters for US/UK English.
• Optional prefixes — (www\.)?, titles, or namespace segments.
• File extensions — \.jpe?g, \.docx? style patterns.
• Flexible formats — optional separators, padding, or suffix characters.

Important Considerations

• Scope — abc? optionalizes only c; use (abc)? for the whole sequence.
• Not lookahead — ? after a token repeats; (?=...) is a separate assertion syntax.
• Empty matches — /a?/ can match zero characters at a position; use anchors to avoid surprises.
• At most one — unlike *, ? never repeats the token twice.
• Lazy form — ?? prefers skipping the optional token when both paths work.
• Greedy default — ? tries to match the token once before skipping when both succeed.

📝 Notes

• ? equals {0,1}—optional, at most once.
• Previous topic: (?=...) positive lookahead.
• Next topic: * zero-or-more quantifier.
• See + for one-or-more repetition.
• See (x|y) alternation when optional choices are not simple zero-or-one.
• Lazy quantifiers: +?, *?, and ?? prefer shorter matches.

💡 Best Practices