MongoDB $round

В MongoDB, $round Операторът на конвейера за агрегиране закръглява число до цяло число или до определен десетичен знак.

Имате възможност да посочите колко знака след десетичната запетая да закръглите числото. За да направите това, предайте втори аргумент. Първият аргумент е числото, което трябва да се закръгли, а вторият (по избор) аргумент е броят на десетичните знаци, до който да се закръгли.

Пример

Да предположим, че имаме колекция, наречена test със следните документи:

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

Можем да използваме $round оператор за закръгляване на стойностите в data поле:

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

Резултат:

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

Посочете десетичен знак

Имаме възможност да използваме втори аргумент, за да посочим колко десетични знака да закръглим числото.

Пример:

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

Резултат:

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

Отрицателни десетични знаци

Вторият аргумент може да бъде всеки валиден израз, който се разрешава до цяло число между -20 и 100, изключително. Следователно можете да посочите отрицателен знак след десетичната запетая.

Когато направите това, числото се закръглява вляво от десетичната запетая. Ако абсолютната стойност на отрицателното цяло число е по-голяма от числото, резултатът е 0 .

Да предположим, че добавяме следните документи към нашата колекция:

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

Ето пример за използване на различни отрицателни десетични знаци при прилагане на $round към тези документи:

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

Резултат:

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

Десично място на нула

Когато предоставите десетичен знак 0 , $round Операторът закръгля с помощта на първата цифра вдясно от десетичната запетая и връща закръглена стойност на цяло число.

Пример:

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

Резултат:

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

Типове числа

Числото за закръгляване може да бъде всеки валиден израз, който се разрешава до цяло число, двойно, десетично или дълго. Връщаната стойност съвпада с типа данни на входната стойност.

Така че, ако добавим следните документи към нашата колекция:

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

Можем да приложим $round към data поле:

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

Резултат:

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

Закръгляване до нулеви десетични знаци

Ако вторият аргумент е null , резултатът е null .

Пример:

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

Резултат:

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

Закръгляване на нулева стойност

Ако стойността, която трябва да се закръгли, е null , резултатът е null .

Да предположим, че добавяме следния документ към колекцията:

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

И ние използваме $round за да закръглите нулевата стойност:

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

Резултат:

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

Безкрайност закръгляване

Ако числото, което трябва да се закръгли, е Infinity , резултатът е Infinity . По същия начин, ако е -Infinity , резултатът е -Infinity .

Нека добавим два документа с такива стойности:

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

И нека ги закръглим:

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

Резултат:

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

Закръгляне NaN

Закръгляване на NaN води до NaN .

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

Резултат:

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

Нечислови типове

Ако се опитате да закръглите стойност, която е грешен тип данни (т.е. не е цяло число, двойна, десетична или дълга), се връща грешка.

Да предположим, че добавяме следния документ към нашата колекция:

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

И сега се опитваме да закръглим data поле:

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

Резултат:

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