MongoDB $runde

I MongoDB er $round aggregeringspipeline-operatør afrunder et tal til et helt heltal eller til en specificeret decimal.

Du har mulighed for at angive, hvor mange decimaler tallet skal afrundes til. For at gøre dette skal du sende et andet argument. Det første argument er antallet, der skal afrundes, og det andet (valgfrit) argument er antallet af decimaler, der skal afrundes til.

Eksempel

Antag, at vi har en samling kaldet test med følgende dokumenter:

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

Vi kan bruge $round operatør for at afrunde værdierne i data felt:

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

Resultat:

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

Angiv en decimal

Vi har mulighed for at bruge et andet argument til at angive, hvor mange decimaler der skal afrundes tallet for.

Eksempel:

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

Resultat:

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

Det andet argument kan være et hvilket som helst gyldigt udtryk, der løses til et heltal mellem -20 og 100, eksklusivt. Derfor kan du angive en negativ decimal.

Når du gør dette, afrundes tallet til venstre for decimalen. Hvis den absolutte værdi af det negative heltal er større end tallet, er resultatet 0 .

Antag, at vi føjer følgende dokumenter til vores samling:

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

Her er et eksempel på brug af forskellige negative decimaler, når du anvender $round til disse dokumenter:

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

Resultat:

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

Nul decimal

Når du angiver en decimal på 0 , $round operator runder med det første ciffer til højre for decimalen og returnerer den afrundede heltalværdi.

Eksempel:

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

Resultat:

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

Taltyper

Tallet, der skal afrundes, kan være et hvilket som helst gyldigt udtryk, der opløses til et heltal, dobbelt, decimal eller langt. Returværdien matcher datatypen for inputværdien.

Så hvis vi tilføjer følgende dokumenter til vores samling:

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

Vi kan anvende $round til data felt:

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

Resultat:

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

Afrunding til nul decimaler

Hvis det andet argument er null , resultatet er null .

Eksempel:

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

Resultat:

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

Afrunding af en nulværdi

Hvis værdien, der skal afrundes, er null , resultatet er null .

Antag, at vi tilføjer følgende dokument til samlingen:

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

Og vi bruger $round for at afrunde nulværdien:

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

Resultat:

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

Runder uendeligt

Hvis tallet, der skal afrundes, er Infinity , resultatet er Infinity . Ligeledes hvis det er -Infinity , resultatet er -Infinity .

Lad os tilføje to dokumenter med sådanne værdier:

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

Og lad os runde dem:

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

Resultat:

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

Afrunding af NaN

Afrunding af NaN resulterer i NaN .

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

Resultat:

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

Ikke-numeriske typer

Hvis du forsøger at afrunde en værdi, der er den forkerte datatype (dvs. den ikke er et heltal, dobbelt, decimal eller lang), returneres en fejl.

Antag, at vi tilføjer følgende dokument til vores samling:

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

Og nu prøver vi at runde data felt:

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

Resultat:

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