MongoDB $ vòng

Trong MongoDB, $round toán tử đường ống tổng hợp làm tròn một số thành một số nguyên hoặc đến một chữ số thập phân được chỉ định.

Bạn có tùy chọn chỉ định bao nhiêu chữ số thập phân để làm tròn số. Để làm điều này, hãy chuyển đối số thứ hai. Đối số đầu tiên là số để làm tròn và đối số thứ hai (tùy chọn) là số vị trí thập phân để làm tròn.

Ví dụ

Giả sử chúng ta có một bộ sưu tập được gọi là test với các tài liệu sau:

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

Chúng ta có thể sử dụng $round toán tử để làm tròn các giá trị trong data lĩnh vực:

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

Kết quả:

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

Chỉ định một vị trí thập phân

Chúng tôi có tùy chọn sử dụng đối số thứ hai để chỉ định bao nhiêu chữ số thập phân để làm tròn số.

Ví dụ:

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

Kết quả:

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

Vị trí thập phân phủ định

Đối số thứ hai có thể là bất kỳ biểu thức hợp lệ nào phân giải thành số nguyên từ -20 đến 100, loại trừ. Do đó, bạn có thể chỉ định một vị trí thập phân âm.

Khi bạn làm điều này, số được làm tròn ở bên trái của chữ số thập phân. Nếu giá trị tuyệt đối của số nguyên âm lớn hơn số này, kết quả là 0 .

Giả sử chúng tôi thêm các tài liệu sau vào bộ sưu tập của mình:

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

Dưới đây là một ví dụ về việc sử dụng các chữ số thập phân âm khác nhau khi áp dụng $round đối với các tài liệu đó:

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

Kết quả:

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

Vị trí thập phân của số 0

Khi bạn cung cấp vị trí thập phân của 0 , $round toán tử làm tròn bằng cách sử dụng chữ số đầu tiên ở bên phải của số thập phân và trả về giá trị số nguyên được làm tròn.

Ví dụ:

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

Kết quả:

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

Loại số

Số để làm tròn có thể là bất kỳ biểu thức hợp lệ nào phân giải thành số nguyên, kép, thập phân hoặc dài. Giá trị trả về khớp với kiểu dữ liệu của giá trị đầu vào.

Vì vậy, nếu chúng tôi thêm các tài liệu sau vào bộ sưu tập của mình:

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

Chúng tôi có thể áp dụng $round đến dữ liệu data lĩnh vực:

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

Kết quả:

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

Làm tròn đến các vị trí thập phân rỗng

Nếu đối số thứ hai là null , kết quả là null .

Ví dụ:

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

Kết quả:

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

Làm tròn giá trị Null

Nếu giá trị được làm tròn là null , kết quả là null .

Giả sử chúng ta thêm tài liệu sau vào bộ sưu tập:

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

Và chúng tôi sử dụng $round để làm tròn giá trị null:

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

Kết quả:

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

Làm tròn vô cực

Nếu số được làm tròn là Infinity , kết quả là Infinity . Tương tự, nếu nó là -Infinity , kết quả là -Infinity .

Hãy thêm hai tài liệu có các giá trị như vậy:

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

Và chúng ta hãy làm tròn chúng:

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

Kết quả:

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

Làm tròn NaN

Làm tròn NaN kết quả là NaN .

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

Kết quả:

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

Loại không phải số

Nếu bạn cố gắng làm tròn một giá trị không đúng kiểu dữ liệu (tức là nó không phải là số nguyên, kép, thập phân hoặc dài), thì sẽ trả về lỗi.

Giả sử chúng ta thêm tài liệu sau vào bộ sưu tập của mình:

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

Và bây giờ chúng tôi cố gắng làm tròn data lĩnh vực:

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

Kết quả:

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