In MongoDB, de $round aggregatiepijplijnoperator rondt een getal af op een geheel getal of op een opgegeven decimaal.
U heeft de mogelijkheid om aan te geven op hoeveel decimalen u het getal wilt afronden. Om dit te doen, geef een tweede argument door. Het eerste argument is het getal dat moet worden afgerond en het tweede (optionele) argument is het aantal decimalen waarop het moet worden afgerond.
Voorbeeld
Stel dat we een verzameling hebben met de naam test met de volgende documenten:
{ "_id" : 1, "data" : 8.99 }
{ "_id" : 2, "data" : 8.45 }
{ "_id" : 3, "data" : 8.451 }
{ "_id" : 4, "data" : -8.99 }
{ "_id" : 5, "data" : -8.45 }
{ "_id" : 6, "data" : -8.451 }
{ "_id" : 7, "data" : 8 }
{ "_id" : 8, "data" : 0 }
We kunnen de $round . gebruiken operator om de waarden in de data . af te ronden veld:
db.test.aggregate(
[
{
$project:
{
_id: 0,
data: 1,
rounded: { $round: [ "$data" ] }
}
}
]
)Resultaat:
{ "data" : 8.99, "rounded" : 9 }
{ "data" : 8.45, "rounded" : 8 }
{ "data" : 8.451, "rounded" : 8 }
{ "data" : -8.99, "rounded" : -9 }
{ "data" : -8.45, "rounded" : -8 }
{ "data" : -8.451, "rounded" : -8 }
{ "data" : 8, "rounded" : 8 }
{ "data" : 0, "rounded" : 0 } Geef een decimale plaats op
We hebben de mogelijkheid om een tweede argument te gebruiken om aan te geven op hoeveel decimalen het getal moet worden afgerond.
Voorbeeld:
db.test.aggregate(
[
{
$project:
{
_id: 0,
data: 1,
rounded: { $round: [ "$data", 1 ] }
}
}
]
)Resultaat:
{ "data" : 8.99, "rounded" : 9 }
{ "data" : 8.45, "rounded" : 8.4 }
{ "data" : 8.451, "rounded" : 8.5 }
{ "data" : -8.99, "rounded" : -9 }
{ "data" : -8.45, "rounded" : -8.4 }
{ "data" : -8.451, "rounded" : -8.5 }
{ "data" : 8, "rounded" : 8 }
{ "data" : 0, "rounded" : 0 } Negatieve decimalen
Het tweede argument kan elke geldige expressie zijn die wordt omgezet in een geheel getal tussen -20 en 100, exclusief. Daarom kunt u een negatieve decimale plaats opgeven.
Wanneer u dit doet, wordt het getal naar links van de komma afgerond. Als de absolute waarde van het negatieve gehele getal groter is dan het getal, is het resultaat 0 .
Stel dat we de volgende documenten aan onze collectie toevoegen:
{ "_id" : 9, "data" : 8111.32 }
{ "_id" : 10, "data" : 8514.321 }
{ "_id" : 11, "data" : 8999.454 }
Hier is een voorbeeld van het gebruik van verschillende negatieve decimalen bij het toepassen van $round naar die documenten:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 9, 10, 11 ] } } },
{
$project:
{
_id: 0,
data: 1,
a: { $round: [ "$data", -1 ] },
b: { $round: [ "$data", -2 ] },
c: { $round: [ "$data", -3 ] },
d: { $round: [ "$data", -4 ] },
e: { $round: [ "$data", -5 ] }
}
}
]
).pretty()Resultaat:
{
"data" : 8111.32,
"a" : 8110,
"b" : 8100,
"c" : 8000,
"d" : 10000,
"e" : 0
}
{
"data" : 8514.321,
"a" : 8510,
"b" : 8500,
"c" : 9000,
"d" : 10000,
"e" : 0
}
{
"data" : 8999.454,
"a" : 9000,
"b" : 9000,
"c" : 9000,
"d" : 10000,
"e" : 0
} Decimaal nul
Wanneer u een decimaal 0 . opgeeft , de $round operator rondt af met het eerste cijfer rechts van het decimaalteken en retourneert het afgeronde gehele getal.
Voorbeeld:
db.test.aggregate(
[
{
$project:
{
_id: 0,
data: 1,
rounded: { $round: [ "$data", 0 ] }
}
}
]
)Resultaat:
{ "data" : 8.99, "rounded" : 9 }
{ "data" : 8.45, "rounded" : 8 }
{ "data" : 8.451, "rounded" : 8 }
{ "data" : -8.99, "rounded" : -9 }
{ "data" : -8.45, "rounded" : -8 }
{ "data" : -8.451, "rounded" : -8 }
{ "data" : 8, "rounded" : 8 }
{ "data" : 0, "rounded" : 0 }
{ "data" : 8111.32, "rounded" : 8111 }
{ "data" : 8514.321, "rounded" : 8514 }
{ "data" : 8999.454, "rounded" : 8999 } Nummertypen
Het af te ronden getal kan elke geldige uitdrukking zijn die wordt omgezet in een geheel getal, dubbel, decimaal of lang. De retourwaarde komt overeen met het gegevenstype van de invoerwaarde.
Dus als we de volgende documenten aan onze collectie toevoegen:
{ "_id" : 12, "data" : NumberDecimal("128.4585") }
{ "_id" : 13, "data" : NumberDecimal("128.12345678912") }
We kunnen $round apply toepassen naar de data veld:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 12, 13 ] } } },
{
$project:
{
_id: 0,
data: 1,
a: { $round: [ "$data", -1 ] },
b: { $round: [ "$data", 0 ] },
c: { $round: [ "$data", 3 ] },
d: { $round: [ "$data", 4 ] },
e: { $round: [ "$data", 5 ] }
}
}
]
).pretty()Resultaat:
{
"data" : NumberDecimal("128.4585"),
"a" : NumberDecimal("1.3E+2"),
"b" : NumberDecimal("128"),
"c" : NumberDecimal("128.458"),
"d" : NumberDecimal("128.4585"),
"e" : NumberDecimal("128.45850")
}
{
"data" : NumberDecimal("128.12345678912"),
"a" : NumberDecimal("1.3E+2"),
"b" : NumberDecimal("128"),
"c" : NumberDecimal("128.123"),
"d" : NumberDecimal("128.1235"),
"e" : NumberDecimal("128.12346")
} Afronding naar nul decimalen
Als het tweede argument null . is , het resultaat is null .
Voorbeeld:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 1, 2, 3 ] } } },
{
$project:
{
_id: 0,
data: 1,
rounded: { $round: [ "$data", null ] }
}
}
]
)Resultaat:
{ "data" : 8.99, "rounded" : null }
{ "data" : 8.45, "rounded" : null }
{ "data" : 8.451, "rounded" : null } Een nulwaarde afronden
Als de af te ronden waarde null . is , het resultaat is null .
Stel dat we het volgende document aan de collectie toevoegen:
{ "_id" : 14, "data" : null }
En we gebruiken $round om de null-waarde af te ronden:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 14 ] } } },
{
$project:
{
_id: 0,
data: 1,
rounded: { $round: [ "$data", null ] }
}
}
]
)Resultaat:
{ "data" : null, "rounded" : null } Oneindigheid afronden
Als het af te ronden getal Infinity is , het resultaat is Infinity . Evenzo, als het -Infinity . is , het resultaat is -Infinity .
Laten we twee documenten met dergelijke waarden toevoegen:
{ "_id" : 15, "data" : Infinity }
{ "_id" : 16, "data" : -Infinity } En laten we ze afronden:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 15, 16 ] } } },
{
$project:
{
_id: 0,
data: 1,
rounded: { $round: [ "$data", 2 ] }
}
}
]
)Resultaat:
{ "data" : Infinity, "rounded" : Infinity }
{ "data" : -Infinity, "rounded" : -Infinity } NaN afronden
Afronding NaN resulteert in NaN .
db.test.aggregate(
[
{ $match: { _id: { $in: [ 1, 2 ] } } },
{
$project:
{
_id: 0,
data: 1,
rounded: { $round: [ "$data" * 2 ] }
}
}
]
)Resultaat:
{ "data" : 8.99, "rounded" : NaN }
{ "data" : 8.45, "rounded" : NaN } Niet-numerieke typen
Als u een waarde probeert af te ronden die van het verkeerde gegevenstype is (d.w.z. het is geen geheel getal, dubbel, decimaal of lang), wordt een fout geretourneerd.
Stel dat we het volgende document aan onze collectie toevoegen:
{ "_id" : 17, "data" : "Thirty five" }
En nu proberen we de data af te ronden veld:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 17 ] } } },
{
$project:
{
_id: 0,
data: 1,
rounded: { $round: [ "$data" ] }
}
}
]
)Resultaat:
uncaught exception: Error: command failed: {
"ok" : 0,
"errmsg" : "$round only supports numeric types, not string",
"code" : 51081,
"codeName" : "Location51081"
} : aggregate failed :
[email protected]/mongo/shell/utils.js:25:13
[email protected]/mongo/shell/assert.js:18:14
[email protected]/mongo/shell/assert.js:639:17
[email protected]/mongo/shell/assert.js:729:16
[email protected]/mongo/shell/db.js:266:5
[email protected]/mongo/shell/collection.js:1058:12
@(shell):1:1