The $abs operator returns the absolute value of a number in MongoDB aggregation pipelines. It is a simple math operator that turns negative values into positive ones while leaving positive values unchanged.
Convert negatives to positives.
One expression inside $abs.
Add computed fields easily.
Work on document fields.
Finance, normalization, QA.
Know how null inputs behave.
In MongoDB’s aggregation framework, the $abs operator computes the absolute value of a numeric expression. For example, -10 becomes 10, and 15 stays 15. This is useful when you care about magnitude rather than sign — such as transaction amounts, price differences, or error distances.
Think of $abs as MongoDB’s version of JavaScript’s Math.abs(). Use it inside aggregation expression stages, not as a standalone query filter operator.
The $abs operator takes one numeric expression:
{ $abs: <expression> }$abs — returns the absolute value of the expression that follows.<expression> — can be a field path ("$amount"), a literal number, or another numeric expression.$project, $addFields, or $set.null, the result is null.| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator |
| Syntax | { $abs: <expression> } |
| Input | Number or numeric expression |
| Output | Non-negative number (or null) |
| Common stages | $project, $addFields, $set |
{
$abs: -20
}Returns 20
{
$abs: "$amount"
}Absolute field value
{
$abs: null
}Returns null
{
$abs: 0
}Returns 0
Walk through sample data, an aggregation pipeline, and the output step by step.
Start with a simple transactions collection and compute absolute amounts with $project.
Suppose you have a transactions collection with an amount field. Some amounts are negative (refunds or debits):
[
{ "_id": ObjectId("609c26812e9274a86871bc6a"), "amount": -10 },
{ "_id": ObjectId("609c26812e9274a86871bc6b"), "amount": 15 },
{ "_id": ObjectId("609c26812e9274a86871bc6c"), "amount": -20 }
]Use $project to add a new field called absoluteAmount:
db.transactions.aggregate([
{
$project: {
absoluteAmount: { $abs: "$amount" }
}
}
])amount is -10, so absoluteAmount becomes 10.amount is already 15, so it stays 15.amount is -20, so absoluteAmount becomes 20.Combine $abs with other operators for real reporting and data-cleaning tasks.
When comparing expected and actual values, the sign of the difference may not matter — only how far off you are:
db.inventory.aggregate([
{
$project: {
item: 1,
expected: 1,
actual: 1,
variance: {
$abs: { $subtract: [ "$actual", "$expected" ] }
}
}
}
])$subtract finds the signed difference. $abs removes the sign so both overages and shortages are measured as positive distances.
Add a normalized field without changing the original signed value:
db.ledger.aggregate([
{
$addFields: {
normalizedAmount: { $abs: "$amount" },
direction: {
$cond: [
{ $gte: [ "$amount", 0 ] },
"credit",
"debit"
]
}
}
}
])Keep the original signed amount for accounting, but use normalizedAmount when you need totals, charts, or comparisons based on magnitude.
You can pass a literal number or nested expression directly:
db.samples.aggregate([
{
$project: {
fromLiteral: { $abs: -42 },
fromMultiply: { $abs: { $multiply: [ "$score", -1 ] } }
}
}
]){ $abs: -42 } always returns 42. When applied to an expression like { $multiply: [ "$score", -1 ] }, it flips the sign of the computed result.
$abs WorksThe pipeline evaluates the input — a field like "$amount" or a numeric expression.
Negative numbers become positive. Positive numbers and zero stay unchanged.
The computed value is written to the field you define in $project or $addFields.
You get magnitude-based values ready for charts, totals, and comparisons.
The $abs operator is a small but essential tool in MongoDB aggregation pipelines. It lets you work with numeric magnitude instead of sign, which is especially helpful for financial data, inventory variance, and data normalization tasks.
For beginners, the key idea is simple: wrap any numeric expression in { $abs: ... } inside a stage like $project, and MongoDB returns the non-negative result.
$abs when magnitude matters more than sign$subtract for variance calculations$ifNull when needed$abs as a query filter operator outside expressionsnull input returns null$absUse these points when writing your next aggregation pipeline.
Removes negative signs.
Purpose{ $abs: expr }
$project, $addFields, $set.
UsageGreat for transaction data.
Use casenull in → null out.
Edge caseContinue with $acos, $round, and other aggregation pipeline operators.
5 people found this page helpful