In MongoDB, de $trunc aggregatiepijplijnoperator kapt een getal af tot een geheel getal of een opgegeven decimaal.
U hebt de mogelijkheid om op te geven voor hoeveel decimalen het getal moet worden afgekapt. Om dit te doen, geef een tweede argument door. Het eerste argument is het getal dat moet worden afgekapt en het tweede (optionele) argument is het aantal decimalen waarop het moet worden afgekapt.
Als u het tweede argument weglaat, worden alle cijfers rechts van het decimaalteken afgekapt en wordt het gehele gehele getal geretourneerd.
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 $trunc . gebruiken operator om de waarden in de data . af te kappen veld:
db.test.aggregate(
[
{
$project:
{
_id: 0,
data: 1,
truncated: { $trunc: [ "$data" ] }
}
}
]
)Resultaat:
{ "data" : 8.99, "truncated" : 8 }
{ "data" : 8.45, "truncated" : 8 }
{ "data" : 8.451, "truncated" : 8 }
{ "data" : -8.99, "truncated" : -8 }
{ "data" : -8.45, "truncated" : -8 }
{ "data" : -8.451, "truncated" : -8 }
{ "data" : 8, "truncated" : 8 }
{ "data" : 0, "truncated" : 0 }
Merk op dat $trunc rondt geen getallen af zoals $round doet. De $trunc operator kapt het nummer gewoon af. Als we $round . hadden toegepast voor deze verzameling zouden het eerste en het vierde document zijn afgerond op 9 en -9 respectievelijk.
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 afgekapt.
Voorbeeld:
db.test.aggregate(
[
{
$project:
{
_id: 0,
data: 1,
truncated: { $trunc: [ "$data", 1 ] }
}
}
]
)Resultaat:
{ "data" : 8.99, "truncated" : 8.9 }
{ "data" : 8.45, "truncated" : 8.4 }
{ "data" : 8.451, "truncated" : 8.4 }
{ "data" : -8.99, "truncated" : -8.9 }
{ "data" : -8.45, "truncated" : -8.4 }
{ "data" : -8.451, "truncated" : -8.4 }
{ "data" : 8, "truncated" : 8 }
{ "data" : 0, "truncated" : 0 }
Nogmaals, dit kapt eenvoudig het nummer af. Als we $round . hadden gebruikt , zou het sommige van deze getallen hebben afgerond.
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 links van de komma afgekapt. Als de absolute waarde van het negatieve gehele getal groter is dan het aantal cijfers links van het decimaalteken, 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 $trunc naar die documenten:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 9, 10, 11 ] } } },
{
$project:
{
_id: 0,
data: 1,
a: { $trunc: [ "$data", -1 ] },
b: { $trunc: [ "$data", -2 ] },
c: { $trunc: [ "$data", -3 ] },
d: { $trunc: [ "$data", -4 ] },
e: { $trunc: [ "$data", -5 ] }
}
}
]
).pretty()Resultaat:
{
"data" : 8111.32,
"a" : 8110,
"b" : 8100,
"c" : 8000,
"d" : 0,
"e" : 0
}
{
"data" : 8514.321,
"a" : 8510,
"b" : 8500,
"c" : 8000,
"d" : 0,
"e" : 0
}
{
"data" : 8999.454,
"a" : 8990,
"b" : 8900,
"c" : 8000,
"d" : 0,
"e" : 0
} Decimaal nul
Wanneer u een decimaal 0 . opgeeft , de $trunc operator kapt alle cijfers rechts van het decimaalteken af en geeft het gehele gehele getal terug.
Voorbeeld:
db.test.aggregate(
[
{
$project:
{
_id: 0,
data: 1,
truncated: { $trunc: [ "$data", 0 ] }
}
}
]
)Resultaat:
{ "data" : 8.99, "truncated" : 8 }
{ "data" : 8.45, "truncated" : 8 }
{ "data" : 8.451, "truncated" : 8 }
{ "data" : -8.99, "truncated" : -8 }
{ "data" : -8.45, "truncated" : -8 }
{ "data" : -8.451, "truncated" : -8 }
{ "data" : 8, "truncated" : 8 }
{ "data" : 0, "truncated" : 0 }
{ "data" : 8111.32, "truncated" : 8111 }
{ "data" : 8514.321, "truncated" : 8514 }
{ "data" : 8999.454, "truncated" : 8999 } Nummertypen
Het af te kappen 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 $trunc . toepassen naar de data veld:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 12, 13 ] } } },
{
$project:
{
_id: 0,
data: 1,
a: { $trunc: [ "$data", -1 ] },
b: { $trunc: [ "$data", 0 ] },
c: { $trunc: [ "$data", 3 ] },
d: { $trunc: [ "$data", 4 ] },
e: { $trunc: [ "$data", 5 ] }
}
}
]
).pretty()Resultaat:
{
"data" : NumberDecimal("128.4585"),
"a" : NumberDecimal("1.2E+2"),
"b" : NumberDecimal("128"),
"c" : NumberDecimal("128.458"),
"d" : NumberDecimal("128.4585"),
"e" : NumberDecimal("128.45850")
}
{
"data" : NumberDecimal("128.12345678912"),
"a" : NumberDecimal("1.2E+2"),
"b" : NumberDecimal("128"),
"c" : NumberDecimal("128.123"),
"d" : NumberDecimal("128.1234"),
"e" : NumberDecimal("128.12345")
} Afkappen tot 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,
truncated: { $trunc: [ "$data", null ] }
}
}
]
)Resultaat:
{ "data" : 8.99, "truncated" : null }
{ "data" : 8.45, "truncated" : null }
{ "data" : 8.451, "truncated" : null } Een nulwaarde afkappen
Als de af te kappen waarde null . is , het resultaat is null .
Stel dat we het volgende document aan de collectie toevoegen:
{ "_id" : 14, "data" : null }
En we gebruiken $trunc om de null-waarde af te kappen:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 14 ] } } },
{
$project:
{
_id: 0,
data: 1,
truncated: { $trunc: [ "$data", null ] }
}
}
]
)Resultaat:
{ "data" : null, "truncated" : null } Oneindigheid afkappen
Als het getal dat moet worden afgekapt 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 inkorten:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 15, 16 ] } } },
{
$project:
{
_id: 0,
data: 1,
truncated: { $trunc: [ "$data", 2 ] }
}
}
]
)Resultaat:
{ "data" : Infinity, "truncated" : Infinity }
{ "data" : -Infinity, "truncated" : -Infinity } NaN afkappen
Afkappen van NaN resulteert in NaN .
db.test.aggregate(
[
{ $match: { _id: { $in: [ 1, 2 ] } } },
{
$project:
{
_id: 0,
data: 1,
truncated: { $trunc: [ "$data" * 2 ] }
}
}
]
)Resultaat:
{ "data" : 8.99, "truncated" : NaN }
{ "data" : 8.45, "truncated" : NaN } Niet-numerieke typen
Als u een waarde probeert af te kappen 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 kappen veld:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 17 ] } } },
{
$project:
{
_id: 0,
data: 1,
truncated: { $trunc: [ "$data" ] }
}
}
]
)Resultaat:
uncaught exception: Error: command failed: {
"ok" : 0,
"errmsg" : "$trunc 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