The $split operator breaks a string into an array of substrings using a delimiter. Use it to parse comma-separated tags, email addresses, file paths, and other structured text stored as a single field.
Split by delimiter.
[ string, delimiter ].
Comma, space, @.
New array fields.
Tags, emails, paths.
Split vs join.
In MongoDB’s aggregation framework, the $split operator divides a string wherever a delimiter appears and returns an array of substrings. For example, { $split: [ "a,b,c", "," ] } returns ["a", "b", "c"].
This is the opposite of $concat, which joins strings together. After splitting, you can use $arrayElemAt, $size, or $sortArray on the resulting array.
If the delimiter is not found, MongoDB returns an array with the whole string as one element. Empty trailing segments are preserved: "a,b," split on "," gives ["a", "b", ""].
The $split operator takes a string and a delimiter:
{ $split: [ <string expression>, <delimiter> ] }{ $split: [ "a,b,c", "," ] }
// Result: ["a", "b", "c"]
{ $split: [ "user@example.com", "@" ] }
// Result: ["user", "example.com"]
{ $split: [ "hello", "," ] }
// Result: ["hello"] (delimiter not found)[ entire string ].$project, $addFields, or $set.null, the result is null.$split: ["a,b", ","] → ["a", "b"]$concat: ["a", ",", "b"] → "a,b"| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (string) |
| Syntax | { $split: [ string, delimiter ] } |
| Output | Array of strings |
| No delimiter match | [ original string ] |
| Common stages | $project, $addFields, $set |
{
$split: ["$csv", ","]
}CSV-like values
{
$split: ["$email", "@"]
}Local + domain
{
$split: ["$path", "/"]
}Path segments
$arrayElemAt: [...]After split
Parse comma-separated tags, split email addresses, break file paths into segments, and extract the first part with $split.
Turn a single CSV-style string field into a proper array of tags.
Suppose you have an articles collection with string fields to parse:
[
{
"_id": 1,
"title": "MongoDB Tips",
"tagCsv": "mongodb,database,tutorial",
"email": "alice@example.com"
},
{
"_id": 2,
"title": "Node Guide",
"tagCsv": "nodejs,javascript",
"email": "bob@company.org"
},
{
"_id": 3,
"title": "No Tags",
"tagCsv": "draft",
"email": "carol@test.io"
}
]Convert a CSV string into an array:
db.articles.aggregate([
{
$project: {
title: 1,
tags: {
$split: [ "$tagCsv", "," ]
}
}
}
])MongoDB splits at every comma. A string with no comma returns a one-element array.
Parse structured strings and pull out individual parts.
Separate the local part from the domain:
db.articles.aggregate([
{
$project: {
title: 1,
emailParts: {
$split: [ "$email", "@" ]
}
}
}
])
// alice@example.com → ["alice", "example.com"]
// bob@company.org → ["bob", "company.org"]Use $arrayElemAt on the result to get index 0 (username) or 1 (domain) separately.
Break a path string into folder segments:
db.files.aggregate([
{
$project: {
name: 1,
pathSegments: {
$split: [ "$filepath", "/" ]
}
}
}
])
// "/docs/reports/2024.pdf"
// → ["", "docs", "reports", "2024.pdf"]Leading slashes produce an empty first segment. Filter empty strings afterward if needed.
Combine $split with $arrayElemAt to get one value:
db.articles.aggregate([
{
$project: {
title: 1,
primaryTag: {
$arrayElemAt: [
{ $split: [ "$tagCsv", "," ] },
0
]
}
}
}
])
// tagCsv: "mongodb,database,tutorial"
// primaryTag: "mongodb"Split first, then pick an index. This pattern is useful when only the first segment matters for grouping or display.
Chain with $size to count how many tags were parsed:
db.articles.aggregate([
{
$project: {
title: 1,
tagCount: {
$size: {
$split: [ "$tagCsv", "," ]
}
}
}
}
])$split produces an array; $size counts its elements. Useful for validation and reporting.
$split WorksThe first argument resolves to a string (field path, literal, or nested expression).
MongoDB finds every occurrence of the delimiter and cuts the string at those positions.
Each piece between delimiters becomes an array element. Empty segments are kept.
Use with $arrayElemAt, $size, or $sortArray.
The $split operator converts delimited strings into arrays inside aggregation pipelines. It is essential for parsing legacy CSV fields, email addresses, and paths before further array processing.
Chain it with $arrayElemAt to pick one part, or $size to count segments. Next in the series: $sqrt.
$split to normalize CSV-like string fields into arrays$arrayElemAt when you need a single segment$trim on segments if values may have extra whitespace$ifNull: [ "$field", "" ]$size for validation$split (string → array) with $concat (strings → string)$split uses literal delimiter strings only$splitUse these points when parsing strings in MongoDB pipelines.
By delimiter.
PurposeTwo arguments.
SyntaxOne-element array.
RulePick one part.
ChainingSplit vs join.
CompareMove on to $sqrt for square root calculations, or review $concat for joining strings.
5 people found this page helpful