MongoDB $round

W MongoDB $round Operator potoku agregacji zaokrągla liczbę do liczby całkowitej lub do określonego miejsca dziesiętnego.

Masz możliwość określenia, o ile miejsc dziesiętnych należy zaokrąglić liczbę. Aby to zrobić, przekaż drugi argument. Pierwszy argument to liczba do zaokrąglenia, a drugi (opcjonalny) argument to liczba miejsc dziesiętnych, do których należy go zaokrąglić.

Przykład

Załóżmy, że mamy kolekcję o nazwie test z następującymi dokumentami:

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

Możemy użyć $round operator do zaokrąglania wartości w data pole:

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

Wynik:

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

Określ miejsce dziesiętne

Mamy możliwość użycia drugiego argumentu, aby określić, do ilu miejsc dziesiętnych należy zaokrąglić liczbę.

Przykład:

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

Wynik:

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

Ujemne miejsca dziesiętne

Drugi argument może być dowolnym poprawnym wyrażeniem, które daje w wyniku liczbę całkowitą z przedziału od -20 do 100, z wyłączeniem. Dlatego możesz określić ujemne miejsce dziesiętne.

Gdy to zrobisz, liczba zostanie zaokrąglona do lewej strony miejsca dziesiętnego. Jeśli wartość bezwzględna ujemnej liczby całkowitej jest większa niż liczba, wynikiem jest 0 .

Załóżmy, że do naszej kolekcji dodamy następujące dokumenty:

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

Oto przykład użycia różnych ujemnych miejsc dziesiętnych podczas stosowania $round do tych dokumentów:

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

Wynik:

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

Dziesiętne miejsce zera

Gdy podasz miejsce dziesiętne 0 , $round operator zaokrągla pierwszą cyfrę po prawej stronie przecinka i zwraca zaokrągloną wartość całkowitą.

Przykład:

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

Wynik:

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

Liczba do zaokrąglenia może być dowolnym prawidłowym wyrażeniem, którego wynikiem jest liczba całkowita, podwójna, dziesiętna lub długa. Zwracana wartość odpowiada typowi danych wartości wejściowej.

Jeśli więc dodamy do naszej kolekcji następujące dokumenty:

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

Możemy zastosować $round do 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()

Wynik:

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

Zaokrąglanie do zerowych miejsc dziesiętnych

Jeśli drugim argumentem jest null , wynik to null .

Przykład:

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

Wynik:

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

Zaokrąglanie wartości zerowej

Jeśli wartość do zaokrąglenia to null , wynik to null .

Załóżmy, że dodajemy do kolekcji następujący dokument:

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

I używamy $round aby zaokrąglić wartość null:

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

Wynik:

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

Zaokrąglanie nieskończoności

Jeśli liczba do zaokrąglenia to Infinity , wynikiem jest Infinity . Podobnie, jeśli jest to -Infinity , wynikiem jest -Infinity .

Dodajmy dwa dokumenty z takimi wartościami:

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

I zaokrąglmy je:

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

Wynik:

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

Zaokrąglanie NaN

Zaokrąglanie NaN wyniki w NaN .

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

Wynik:

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

Typy nieliczbowe

Jeśli spróbujesz zaokrąglić wartość, która jest niewłaściwym typem danych (tzn. nie jest liczbą całkowitą, podwójną, dziesiętną lub długą), zostanie zwrócony błąd.

Załóżmy, że do naszej kolekcji dodamy następujący dokument:

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

A teraz próbujemy zaokrąglić data pole:

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

Wynik:

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