The $floor operator rounds a number down to the nearest integer in MongoDB aggregation pipelines. It is MongoDB’s equivalent of JavaScript’s Math.floor() — useful when you need whole numbers from decimal data.
Drop the decimal part.
One expression inside $floor.
Add rounded fields easily.
-3.2 becomes -4, not -3.
Temperatures, pricing, tiers.
Know the rounding direction.
In MongoDB’s aggregation framework, the $floor operator rounds a numeric expression down to the nearest integer. For example, 23.8 becomes 23, and -3.2 becomes -4 (rounding toward negative infinity). This is useful for temperature displays, whole-unit pricing, age brackets, and any scenario where you need the largest integer less than or equal to a value.
Think of $floor as MongoDB’s version of JavaScript’s Math.floor(). Use it inside aggregation expression stages like $project, not as a standalone query filter operator.
The $floor operator takes one numeric expression:
{ $floor: <expression> }$floor( 23.8 ) → 23
$floor( 23.0 ) → 23
$floor( -3.2 ) → -4 // toward negative infinity
$floor( null ) → null$floor — returns the largest integer less than or equal to the input.<expression> — can be a field path ("$temperature"), a literal number, or another numeric expression.$project, $addFields, or $set.null, the result is null.$floor rounds toward negative infinity (-3.7 → -4). $trunc removes decimals toward zero (-3.7 → -3). $ceil rounds toward positive infinity (-3.2 → -3). Pick the operator that matches your business rule.
| Question | Answer |
|---|---|
| Operator type | Aggregation math expression operator |
| Syntax | { $floor: <expression> } |
| Input | Number or numeric expression |
| Output | Integer (or null) |
| Common stages | $project, $addFields, $set |
{
$floor: 23.8
}Returns 23
{
$floor: "$temperature"
}Round field down
{
$floor: -3.2
}Returns -4
{
$floor: null
}Returns null
Walk through sample data, an aggregation pipeline, and the output step by step.
Start with a temperatures collection and round decimal readings down with $project.
Suppose you have a temperatures collection with location and temperature fields:
[
{ "_id": ObjectId("609c26812e9274a86871bc6a"), "location": "New York", "temperature": 23.5 },
{ "_id": ObjectId("609c26812e9274a86871bc6b"), "location": "Los Angeles", "temperature": 31.8 },
{ "_id": ObjectId("609c26812e9274a86871bc6c"), "location": "Chicago", "temperature": 17.2 }
]Use $project to add a roundedTemperature field:
db.temperatures.aggregate([
{
$project: {
location: 1,
temperature: 1,
roundedTemperature: { $floor: "$temperature" }
}
}
])23.5 → 23 (decimal dropped).31.8 → 31.17.2 → 17.20.0 stay unchanged at 20.Handle negative values, combine with arithmetic, and normalize data for reporting.
$floor behaves differently from $trunc on negative values:
db.readings.aggregate([
{
$project: {
value: 1,
floored: { $floor: "$value" },
truncated: { $trunc: "$value" }
}
}
])
// value: -3.7 → floored: -4, truncated: -3
// value: 4.9 → floored: 4, truncated: 4$floor always moves toward negative infinity. This matters for financial adjustments, altitude readings below sea level, or any signed decimal data.
Calculate how many full boxes fit using $divide and then floor the result:
db.inventory.aggregate([
{
$project: {
item: 1,
totalQty: 1,
boxSize: 1,
fullBoxes: {
$floor: {
$divide: [ "$totalQty", "$boxSize" ]
}
}
}
}
])$divide returns a decimal (e.g. 3.916...). $floor keeps only complete units — leftover items do not count as a full box.
You can pass a literal number or nested expression directly:
db.samples.aggregate([
{
$project: {
fromLiteral: { $floor: 9.99 },
fromAdd: {
$floor: {
$add: [ "$basePrice", "$tax" ]
}
}
}
}
]){ $floor: 9.99 } returns 9. When applied to an expression like { $add: [ "$basePrice", "$tax" ] }, it floors the computed total — useful for display pricing or integer-based billing tiers.
$floor WorksThe pipeline evaluates the input — a field like "$temperature" or a numeric expression.
Decimals are dropped in the downward direction. 23.9 → 23, -3.1 → -4.
The floored value is written to the field you define in $project or $addFields.
You get integer values ready for grouping, display, and integer-based business rules.
The $floor operator is a practical math tool in MongoDB aggregation pipelines. It converts decimal numbers to integers by rounding down, which is especially helpful for temperature data, inventory calculations, and normalized reporting.
For beginners, the key idea is simple: wrap any numeric expression in { $floor: ... } inside a stage like $project, and MongoDB returns the largest integer less than or equal to that value.
$floor when you need the largest integer ≤ the value$divide for whole-unit calculations$ceil and $trunc before choosing$floor with $round (nearest) or $trunc (toward zero)$floor as a query filter operator outside expressionsnull input returns null$floorUse these points when rounding numbers in aggregation pipelines.
Largest integer ≤ value.
Purpose{ $floor: expr }
$project, $addFields, $set.
UsageTemps, units, tiers.
Use case-3.2 → -4, not -3.
Edge caseContinue with $function for custom JavaScript, or review $ceil for rounding up.
5 people found this page helpful