The $regexFindAll operator finds every regular expression match in a string and returns them as an array. Use it when you need all hashtags, mentions, numbers, or tokens — not just the first one.
Every regex hit.
Match objects list.
Position and groups.
$project / $addFields.
Tokenize, count.
All vs first only.
In MongoDB’s aggregation framework, the $regexFindAll operator searches a string for a regular expression pattern and returns an array of match objects. Each object contains match (matched text), idx (start index), and captures (parenthesized groups).
When no matches are found, the result is an empty array [] — not null. This makes it easy to chain with $size, $map, or $filter without extra null checks.
Need only the first match? Use $regexFind instead. Need only yes/no? Use $regexMatch. Use $regexFindAll when you want every occurrence with its text and position.
The $regexFindAll operator takes the same shape as $regexFind:
{
$regexFindAll: {
input: <string expression>,
regex: <pattern expression>,
options: <options expression> // optional
}
}// On one or more matches:
[
{ match: "first hit", idx: 0, captures: [] },
{ match: "second hit", idx: 12, captures: [] }
]
// No matches:
[]input — the string to search (field path or expression).regex — the pattern string or BSON regex literal.options — optional flags like "i" (case insensitive).[] when there are no matches or when input is null.$project, $addFields, or $set (MongoDB 4.2+).| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (string / regex) |
| Syntax | { $regexFindAll: { input, regex, options? } } |
| Output | Array of { match, idx, captures } objects |
| No match | [] (empty array) |
| Common stages | $project, $addFields, $set |
{
$regexFindAll: {
input: "$text",
regex: "#\\w+"
}
}All hashtags
{ $size: "$tags" }Array length
$map + $$this.matchStrings only
[]Empty array
Collect every hashtag, count matches, extract mention handles, and map results to plain strings with $regexFindAll.
Extract every hashtag from a body field with $regexFindAll.
Suppose you have a posts collection:
[
{
"_id": 1,
"author": "Alice",
"body": "Love #mongodb and #database design!"
},
{
"_id": 2,
"author": "Bob",
"body": "No hashtags in this post."
},
{
"_id": 3,
"author": "Carol",
"body": "Thanks @alice and @bob for the help #teamwork"
}
]Find every hashtag in each post body:
db.posts.aggregate([
{
$project: {
author: 1,
body: 1,
hashtags: {
$regexFindAll: {
input: "$body",
regex: "#\\w+"
}
}
}
}
])The pattern #\w+ matches each hash symbol plus word characters. Unlike $regexFind, all matches are returned. Posts with no hashtags get an empty array.
Count matches, flatten to strings, and extract @mentions.
Use $size on the result array:
db.posts.aggregate([
{
$project: {
author: 1,
hashtagCount: {
$size: {
$regexFindAll: {
input: "$body",
regex: "#\\w+"
}
}
}
}
}
])
// Alice: 2, Bob: 0, Carol: 1$size counts array elements. Because $regexFindAll always returns an array (even when empty), you do not need a null check before counting.
Store only the matched text, not the full match objects:
db.posts.aggregate([
{
$project: {
author: 1,
tagList: {
$map: {
input: {
$regexFindAll: {
input: "$body",
regex: "#\\w+"
}
},
as: "hit",
in: "$$hit.match"
}
}
}
}
])
// Alice: ["#mongodb", "#database"]
// Bob: []
// Carol: ["#teamwork"]$map walks each match object and projects $$hit.match. This is a common pattern when downstream stages expect a simple string array.
Pull every user mention from a post:
db.posts.aggregate([
{
$project: {
author: 1,
mentions: {
$map: {
input: {
$regexFindAll: {
input: "$body",
regex: "@(\\w+)"
}
},
as: "m",
in: {
$arrayElemAt: [ "$$m.captures", 0 ]
}
}
}
}
}
])
// Carol: ["alice", "bob"]The capture group (\w+) stores the username without the @ symbol. $map reads captures[0] from each match object.
Parse numeric tokens from a log message field:
db.logs.aggregate([
{
$project: {
message: 1,
numbers: {
$map: {
input: {
$regexFindAll: {
input: "$message",
regex: "\\d+"
}
},
as: "n",
in: { $toInt: "$$n.match" }
}
}
}
}
])
// "Error 404 on port 8080" → numbers: [404, 8080]\d+ matches one or more digits. $toInt converts each matched string to a number for further math or filtering.
$size.$regexFindAll WorksThe pipeline resolves the string (input) and compiles the pattern (regex) with any options.
MongoDB searches left to right and records every non-overlapping substring that satisfies the pattern.
Every hit is stored as { match, idx, captures }. No matches produce [].
Use $map, $size, or $filter on the result array.
The $regexFindAll operator finds every regular expression match in a string and returns them as an array of { match, idx, captures } objects. When nothing matches, you get [].
Pair it with $map to flatten results or $size to count them. For a single match, use $regexFind. For a boolean check, use $regexMatch. Next in the series: $regexMatch.
$size or $map on the result$regexFind when you only need the first matchnull check needed)$regexMatch for simple existence checksnull for no match — the result is []$regexFindAll as a query filter (it is expression-only)$regexFindAll with query $regex$regexFindAllUse these points when extracting every regex match in pipelines.
Every occurrence.
PurposeSame as $regexFind.
SyntaxList of objects.
OutputFlatten or count.
ChainingNo matches found.
Edge caseMove on to $regexMatch for boolean pattern checks, or review $regexFind for the first match only.
5 people found this page helpful