JavaScript RegExp $ Quantifier

What You’ll Learn

The $ quantifier is an end anchor. It matches a position—not a character—at the end of the input string. Combine it with literal text or groups to require a suffix: file extensions, domain endings, punctuation, or keywords that must appear last.

Introduction

Many validation tasks care about where text appears, not just what it contains. Does a filename end in .pdf? Does a sentence end with a question mark? Does a log line finish with OK? The $ anchor answers those questions by insisting the match reaches the end of the string.

Without $, the pattern /world/ matches "hello world" anywhere the letters appear. Adding $ turns it into /world$/, which matches only when world is the final characters—a much stricter and often more useful rule.

Understanding the $ End Anchor

Place $ at the end of a pattern (or before a trailing flag like /i). It asserts that the current match position is at the end of the input. With the m multiline flag, it also matches immediately before each newline, so each line can have its own “end.”

const ok = "hello world";
const no = "world hello";

/world$/.test(ok);  // true  — ends with "world"
/world$/.test(no);  // false — "world" is not at the end

/end$/m.test("line one end\nline two end"); // true — both lines end with "end"

$ is zero-width: it checks a boundary without consuming characters. That is why /world$/ on "hello world" matches the substring "world" at the string tail.

How to Use the $ Anchor

Append text or groups before $ to require a suffix, or pair ^ and $ to match an entire line or string:

/\.pdf$/i.test("report.PDF");     // true — extension at end
/\d+$/.test("item42");             // true — trailing digits
/^.+$/m.test("a\nb\nc");           // true — each line non-empty

"photo.jpg".replace(/\.(jpg|png)$/i, ".webp"); // "photo.webp"

Use test() for yes/no checks, match() to extract the suffix, and replace() to rewrite endings. Add m when working with multi-line strings.

📝 Syntax

/suffix$/              // ends with literal "suffix"
/\.(jpg|png)$/i        // image extension at end
/\d+$/                 // one or more digits at end
/pattern$/m            // end of each line (with m)
/^start.+end$/         // whole string from start to end
new RegExp("end$", "m") // constructor form

Common patterns

• /\.(pdf|docx?)$/i — document file extensions.
• /[!?.]$/ — sentence ends with punctuation.
• /^\s*$/m — find blank lines (with m).
• /ing$/i — words ending in ing.
• /^.+$/gm — capture every non-empty line.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover basic suffix matching, multiline line ends, file extensions, trailing digits, and full-line validation with ^ and $.

const phrases = ["hello world", "world peace", "say world"];

phrases.forEach((s) => {
  console.log(s, /world$/.test(s));
});
// "hello world" true
// "world peace" false
// "say world"   true

hello world true
world peace false
say world true

const text = "line one end\nline two end\nno match";

console.log(/end$/.test(text));    // false — whole string ends with "match"
console.log(/end$/m.test(text));   // true — lines 1 and 2 end with "end"

console.log(text.match(/end$/gm)); // ["end", "end"]

false
true
["end", "end"]

const isImage = /\.(jpe?g|png)$/i;

console.log(isImage.test("photo.jpg"));      // true
console.log(isImage.test("photo.JPEG"));     // true
console.log(isImage.test("photo.jpg.bak")); // false

true
true
false

const items = ["widget7", "widget42", "widget"];

items.forEach((name) => {
  const m = name.match(/(\d+)$/);
  console.log(name, m ? m[1] : "no digits");
});
// widget7  "7"
// widget42 "42"
// widget   "no digits"

widget7 7
widget42 42
widget no digits

const hexColor = /^#[0-9a-f]{6}$/i;

console.log(hexColor.test("#ff00aa"));     // true
console.log(hexColor.test("#ff00"));       // false — too short
console.log(hexColor.test("color #ff00aa")); // false — extra text

true
false
false

🚀 Common Use Cases

• File type checks — allow uploads only when the name ends with a safe extension.
• URL/path suffixes — detect trailing slashes or specific route endings.
• Input validation — require entire field to match a format with ^…$.
• Log parsing — find lines ending in ERROR, OK, or a status code.
• Natural language — detect sentences ending in ?, !, or .
• Data cleanup — strip or rewrite suffixes with replace(/suffix$/, …).

Important Considerations

• Multiline text — add m when $ should apply per line, not only at string end.
• Trailing whitespace — spaces before the end prevent $ from matching where you expect; trim or use \s*$ if needed.
• Not a character — $ is an assertion; it does not match the last letter itself.
• Replacement confusion — $1 in replace strings is a backreference, not an anchor.
• Windows line endings — \r\n may leave \r before $ matches; normalize line endings when parsing.
• Partial vs full match — without ^, /pattern$/ still allows extra text at the start.

📝 Notes

• $ pairs naturally with ^ for whole-string or whole-line validation.
• See the m modifier for per-line $ behavior.
• Previous topic: m multiline flag.
• Next topic: ?! negative lookahead.
• \b word boundaries differ from $; see \b.
• In replacement strings, use $$ for a literal dollar sign.

💡 Best Practices