JavaScript RegExp . Metacharacter

What You’ll Learn

The dot . is the regex wildcard: it matches almost any single character on a line. Use it for flexible patterns like c.t (cat, cut, cot), but escape it as \. when you need a literal period in file names or decimals.

Introduction

Sometimes you know part of a pattern but not every character—like the middle letter in a three-letter word. The dot metacharacter fills that gap by matching one character of (almost) any kind.

By default, the dot does not cross line boundaries. That keeps multiline text safe unless you explicitly enable the dotAll (s) flag.

Understanding the . Metacharacter

In a regex pattern, an unescaped . matches exactly one character that is not a line terminator:

/c.t/.test("cat");   // true  ("." matches "a")
/c.t/.test("cut");   // true  ("." matches "u")
/c.t/.test("cart");  // false (extra char after pattern)

/./.test("");        // false (need one char)
/./.test("x");       // true

To match a real period in text (like .pdf), escape it: \.. Without the backslash, the dot remains a wildcard.

How to Use . in JavaScript

Combine the dot with quantifiers and anchors for flexible matching:

"hello".match(/h.llo/);           // ["hello"]
"tag: blue".match(/tag: .+/);     // ["tag: blue"]
"file.txt".match(/\.txt$/);       // [".txt"]

"line1\nline2".match(/line1.line2/);   // null (dot skips newline)
"line1\nline2".match(/line1.line2/s); // match with dotAll

Use .+ for “everything until…” on one line, \. for literal dots, and the s flag when newlines must be included.

📝 Syntax

.               // any char except line break
\.              // literal period
.+              // one or more (greedy)
.*?             // zero or more (lazy)
.{3}            // exactly three chars
/pattern/s      // dotAll: . matches newline too

Common patterns

• /c.t/ — three-char words starting with c, ending with t.
• /\.(pdf|png)$/i — file extension with literal dot.
• /^.{1,10}$/ — string length between 1 and 10 characters.
• /start.+end/s — span across lines with dotAll.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover wildcards, literal dots, greedy matching, file extensions, and dotAll.

const pattern = /c.t/;

console.log(pattern.test("cat"));   // true
console.log(pattern.test("cut"));   // true
console.log(pattern.test("c9t"));   // true
console.log(pattern.test("cart"));  // false

true
true
true
false

console.log(/version \d+\.\d+/.test("version 2.4"));  // true
console.log(/version \d+.\d+/.test("version 2X4"));     // true (dot is wildcard!)

console.log(/\.txt$/.test("notes.txt"));  // true
console.log(/\.txt$/.test("notesXtxt"));  // false

true
true
true
false

const line = "color: deep blue";

const greedy = line.match(/color: .+/);
console.log(greedy[0]); // "color: deep blue"

const lazy = "a1b2".match(/a.+b/);
console.log(lazy[0]);   // "a1b" (.+ is greedy but stops at last possible b)

color: deep blue
a1b

const pdfPattern = /\.pdf$/i;

console.log(pdfPattern.test("report.pdf"));  // true
console.log(pdfPattern.test("report.PDF"));  // true
console.log(pdfPattern.test("reportXpdf"));  // false

true
true
false

const text = "start\nmiddle\nend";

console.log(/start.end/.test(text));    // false
console.log(/start.end/s.test(text));  // true

const regex = /start.end/s;
console.log(regex.dotAll);             // true

false
true
true

🚀 Common Use Cases

• Flexible spelling — match variants with unknown middle characters.
• File extensions — use \. before extension letters.
• Version numbers — pattern \d+\.\d+ for major.minor.
• Key-value parsing — capture values with /key: .+/.
• Multiline blocks — dotAll for HTML or config sections spanning lines.
• Length checks — ^.{8,}$ for minimum character count.

Important Considerations

• Escape literal dots — unescaped . is always a wildcard, never a period.
• Greedy .+ — can over-capture; use lazy .+? or specific classes when precision matters.
• No newline by default — multiline text needs the s flag or explicit [\s\S].
• Not “any string” — one dot equals one character; use quantifiers for longer runs.
• Prefer specific classes — when you know the char type, \d or [a-z] is clearer than ..

📝 Notes

• . = wildcard; \. = literal period.
• dotAll (s flag) lets . match newlines (ES2018+).
• Review \d when you need digits specifically, not any character.
• Next up: \f form feed metacharacter.
• Alternative for “any char including newline”: [\s\S] works without the s flag.
• In character classes [.], the dot is usually literal—no escape needed inside brackets.

💡 Best Practices