MongoDB $round

In MongoDB die $round Der Aggregations-Pipeline-Operator rundet eine Zahl auf eine ganze Zahl oder auf eine bestimmte Dezimalstelle.

Sie haben die Möglichkeit festzulegen, auf wie viele Nachkommastellen die Zahl gerundet werden soll. Übergeben Sie dazu ein zweites Argument. Das erste Argument ist die zu rundende Zahl und das zweite (optionale) Argument ist die Anzahl der Dezimalstellen, auf die gerundet werden soll.

Beispiel

Angenommen, wir haben eine Sammlung namens test mit folgenden Dokumenten:

{ "_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 }

Wir können den $round verwenden Operator zum Runden der Werte in den data Feld:

db.test.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data" ] }
          }
     }
   ]
)

Ergebnis:

{ "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 }

Geben Sie eine Dezimalstelle an

Wir haben die Möglichkeit, ein zweites Argument zu verwenden, um anzugeben, auf wie viele Dezimalstellen die Zahl gerundet werden soll.

Beispiel:

db.test.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data", 1 ] }
          }
     }
   ]
)

Ergebnis:

{ "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 }

Negative Dezimalstellen

Das zweite Argument kann ein beliebiger gültiger Ausdruck sein, der sich in eine ganze Zahl zwischen -20 und 100 (ausschließlich) auflösen lässt. Daher können Sie eine negative Dezimalstelle angeben.

Dabei wird die Zahl auf die linke Kommastelle gerundet. Wenn der Absolutwert der negativen Ganzzahl größer als die Zahl ist, ist das Ergebnis 0 .

Angenommen, wir fügen unserer Sammlung die folgenden Dokumente hinzu:

{ "_id" : 9, "data" : 8111.32 }
{ "_id" : 10, "data" : 8514.321 }
{ "_id" : 11, "data" : 8999.454 }

Hier ist ein Beispiel für die Verwendung verschiedener negativer Dezimalstellen bei der Anwendung von $round zu diesen Dokumenten:

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()

Ergebnis:

{
	"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
}

Dezimalstelle von Null

Wenn Sie eine Dezimalstelle von 0 angeben , die $round Der Operator rundet mit der ersten Ziffer rechts vom Dezimaltrennzeichen und gibt den gerundeten ganzzahligen Wert zurück.

Beispiel:

db.test.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data", 0 ] }
          }
     }
   ]
)

Ergebnis:

{ "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 }

Nummerntypen

Die zu rundende Zahl kann ein beliebiger gültiger Ausdruck sein, der zu einer ganzen Zahl, einem Double, einer Dezimalzahl oder einem Long-Wert aufgelöst werden kann. Der Rückgabewert entspricht dem Datentyp des Eingabewerts.

Wenn wir also unserer Sammlung die folgenden Dokumente hinzufügen:

{ "_id" : 12, "data" : NumberDecimal("128.4585") }
{ "_id" : 13, "data" : NumberDecimal("128.12345678912") }

Wir können $round anwenden zu den data Feld:

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()

Ergebnis:

{
	"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")
}

Rundung auf null Dezimalstellen

Wenn das zweite Argument null ist , ist das Ergebnis null .

Beispiel:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data", null ] }
          }
     }
   ]
)

Ergebnis:

{ "data" : 8.99, "rounded" : null }
{ "data" : 8.45, "rounded" : null }
{ "data" : 8.451, "rounded" : null }

Rundung eines Nullwerts

Wenn der zu rundende Wert null ist , ist das Ergebnis null .

Angenommen, wir fügen der Sammlung das folgende Dokument hinzu:

{ "_id" : 14, "data" : null }

Und wir verwenden $round um den Nullwert zu runden:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 14 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data", null ] }
          }
     }
   ]
)

Ergebnis:

{ "data" : null, "rounded" : null }

Unendlich runden

Wenn die zu rundende Zahl Infinity ist , ist das Ergebnis Infinity . Ebenso, wenn es -Infinity ist , ist das Ergebnis -Infinity .

Lassen Sie uns zwei Dokumente mit solchen Werten hinzufügen:

{ "_id" : 15, "data" : Infinity }
{ "_id" : 16, "data" : -Infinity }

Und runden wir sie ab:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 15, 16 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data", 2 ] }
          }
     }
   ]
)

Ergebnis:

{ "data" : Infinity, "rounded" : Infinity }
{ "data" : -Infinity, "rounded" : -Infinity }

NaN runden

Rundung NaN ergibt NaN .

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data" * 2 ] }
          }
     }
   ]
)

Ergebnis:

{ "data" : 8.99, "rounded" : NaN }
{ "data" : 8.45, "rounded" : NaN }

Nicht numerische Typen

Wenn Sie versuchen, einen Wert zu runden, der den falschen Datentyp hat (d. h. er ist keine ganze Zahl, doppelt, dezimal oder lang), wird ein Fehler zurückgegeben.

Angenommen, wir fügen unserer Sammlung das folgende Dokument hinzu:

{ "_id" : 17, "data" : "Thirty five" }

Und jetzt versuchen wir, die data zu runden Feld:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 17 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data" ] }
          }
     }
   ]
)

Ergebnis:

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