MongoDB $kulatý

V MongoDB, $round Operátor agregačního kanálu zaokrouhlí číslo na celé číslo nebo na zadané desetinné místo.

Máte možnost určit, na kolik desetinných míst se má číslo zaokrouhlit. Chcete-li to provést, předejte druhý argument. První argument je číslo, které se má zaokrouhlit, a druhý (volitelný) argument je počet desetinných míst, na který se má zaokrouhlit.

Příklad

Předpokládejme, že máme kolekci nazvanou test s následujícími dokumenty:

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

Můžeme použít $round operátor k zaokrouhlení hodnot v data pole:

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

Výsledek:

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

Zadejte desetinné místo

Máme možnost použít druhý argument k určení, na kolik desetinných míst se má číslo zaokrouhlit.

Příklad:

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

Výsledek:

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

Záporná desetinná místa

Druhým argumentem může být jakýkoli platný výraz, který se překládá na celé číslo mezi -20 a 100, s výjimkou. Proto můžete zadat záporné desetinné místo.

Když to uděláte, číslo se zaokrouhlí nalevo od desetinného místa. Pokud je absolutní hodnota záporného celého čísla větší než číslo, je výsledkem 0 .

Předpokládejme, že do naší sbírky přidáme následující dokumenty:

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

Zde je příklad použití různých záporných desetinných míst při použití $round k těm dokumentům:

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

Výsledek:

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

Desetinné místo od nuly

Když zadáte desetinné místo 0 , $round operátor zaokrouhlí pomocí první číslice napravo od desetinného místa a vrátí zaokrouhlenou hodnotu celého čísla.

Příklad:

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

Výsledek:

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

Typy čísel

Číslo, které se má zaokrouhlit, může být jakýkoli platný výraz, který se rozlišuje na celé číslo, dvojité, desetinné nebo dlouhé. Vrácená hodnota odpovídá datovému typu vstupní hodnoty.

Pokud tedy do naší sbírky přidáme následující dokumenty:

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

Můžeme použít $round na data pole:

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

Výsledek:

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

Zaokrouhlování na nulová desetinná místa

Pokud je druhý argument null , výsledkem je null .

Příklad:

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

Výsledek:

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

Zaokrouhlení hodnoty Null

Pokud je hodnota, která se má zaokrouhlit, null , výsledkem je null .

Předpokládejme, že do sbírky přidáme následující dokument:

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

A my používáme $round pro zaokrouhlení hodnoty null:

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

Výsledek:

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

Zaokrouhlení na nekonečno

Pokud je číslo, které má být zaokrouhleno, Infinity , výsledkem je Infinity . Podobně, pokud je to -Infinity , výsledkem je -Infinity .

Přidejme dva dokumenty s takovými hodnotami:

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

A pojďme je zaokrouhlit:

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

Výsledek:

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

Zaokrouhlení NaN

Zaokrouhlení NaN výsledkem je NaN .

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

Výsledek:

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

Nečíselné typy

Pokud se pokusíte zaokrouhlit hodnotu, která má nesprávný datový typ (tj. není to celé číslo, dvojité, desítkové nebo dlouhé číslo), vrátí se chyba.

Předpokládejme, že do naší sbírky přidáme následující dokument:

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

A nyní se pokusíme zaokrouhlit data pole:

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

Výsledek:

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