MongoDB $ không phải Nhà điều hành đường ống tổng hợp

Trong MongoDB, $not toán tử đường ống tổng hợp đánh giá một boolean và trả về giá trị boolean ngược lại.

Nói cách khác, khi boolean đánh giá là true , $not toán tử trả về false . Và khi boolean đánh giá thành false , $not toán tử trả về true .

Ví dụ

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

{ "_id" : 1, "data" : true }
{ "_id" : 2, "data" : false }

Đây là những gì sẽ xảy ra khi chúng tôi áp dụng $not đến dữ liệu data trường của mỗi tài liệu:

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

Kết quả:

{ "data" : true, "result" : false }
{ "data" : false, "result" : true }

Chúng ta có thể thấy rằng $not trả về phần ngược lại của mỗi boolean.

Các giá trị bằng 0, rỗng và không xác định

$not toán tử đánh giá 0 , null và undefined dưới dạng false - có nghĩa là nó trả về true .

Giả sử chúng ta có các tài liệu sau:

{ "_id" : 3, "data" : 0 }
{ "_id" : 4, "data" : null }
{ "_id" : 5, "data" : undefined }

Đây là những gì sẽ xảy ra khi chúng tôi áp dụng $not :

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 3, 4, 5 ] } } },
     { $project: { 
        _id: 0,
        data: 1,
        result: { $not: [ "$data" ] } } 
         }
   ]
)

Kết quả:

{ "data" : 0, "result" : true }
{ "data" : null, "result" : true }
{ "data" : undefined, "result" : true }

Như mong đợi, tất cả đều trả về true (có nghĩa là họ đã đánh giá là false .

Tất cả các giá trị khác

$not toán tử tất cả các giá trị khác là true - có nghĩa là nó trả về false .

Giả sử chúng ta có các tài liệu sau:

{ "_id" : 6, "data" : [ true ] }
{ "_id" : 7, "data" : [ false ] }
{ "_id" : 8, "data" : 5 }
{ "_id" : 9, "data" : "Bat" }
{ "_id" : 10, "data" : ISODate("2021-01-03T23:30:15.100Z") }

Đây là những gì sẽ xảy ra khi chúng tôi áp dụng $not :

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 6, 7, 8, 9, 10 ] } } },
     { $project: { 
        _id: 0,
        data: 1,
        result: { $not: [ "$data" ] } } 
         }
   ]
)

Kết quả:

{ "data" : [ true ], "result" : false }
{ "data" : [ false ], "result" : false }
{ "data" : 5, "result" : false }
{ "data" : "Bat", "result" : false }
{ "data" : ISODate("2021-01-03T23:30:15.100Z"), "result" : false }

Tất cả đều trả về false (có nghĩa là chúng đánh giá thành true ).

Các trường bị thiếu

Đang áp dụng $not đến một trường không tồn tại sẽ đánh giá là false (có nghĩa là nó trả về true ).

Giả sử chúng ta có tài liệu sau:

{ "_id" : 11 }

Và chúng tôi áp dụng $not về điều đó:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 11 ] } } },
     { $project: { 
        _id: 0,
        data: 1,
        result: { $not: [ "$data" ] } } 
         }
   ]
)

Kết quả:

{ "result" : true }

Phủ nhận một nhà điều hành khác

$not toán tử có thể được sử dụng để phủ định đầu ra boolean của một toán tử khác.

Giả sử chúng ta có một bộ sưu tập có tên là pets với các tài liệu sau:

{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Kangaroo", "weight" : 100 }
{ "_id" : 6, "name" : "Hop", "type" : "Kangaroo", "weight" : 130 }
{ "_id" : 7, "name" : "Punch", "type" : "Kangaroo", "weight" : 200 }
{ "_id" : 8, "name" : "Snap", "type" : "Cat", "weight" : 12 }
{ "_id" : 9, "name" : "Ruff", "type" : "Dog", "weight" : 30 }

Chúng ta có thể sử dụng $not kết hợp với say, $gt để đánh giá trường trọng số:

db.pets.aggregate(
   [
     { $project: { 
        _id: 0,
        name: 1,
        weight: 1,
        result: { $not: [ { $gt: [ "$weight", 100 ] } ] } } 
         }
   ]
)

Kết quả:

{ "name" : "Wag", "weight" : 20, "result" : true }
{ "name" : "Bark", "weight" : 10, "result" : true }
{ "name" : "Meow", "weight" : 7, "result" : true }
{ "name" : "Scratch", "weight" : 8, "result" : true }
{ "name" : "Bruce", "weight" : 100, "result" : true }
{ "name" : "Hop", "weight" : 130, "result" : false }
{ "name" : "Punch", "weight" : 200, "result" : false }
{ "name" : "Snap", "weight" : 12, "result" : true }
{ "name" : "Ruff", "weight" : 30, "result" : true }

Để nhắc lại điều này, đây là một lần nữa nhưng lần này chúng tôi xuất một trường cho $gt kết quả, cũng như trường cho không $gt kết quả:

db.pets.aggregate(
   [
     { $project: { 
        _id: 0,
        weight: 1,
        gt: { $gt: [ "$weight", 100 ] },
        notGt: { $not: [ { $gt: [ "$weight", 100 ] } ] } } 
         }
   ]
)

Kết quả:

{ "weight" : 20, "gt" : false, "notGt" : true }
{ "weight" : 10, "gt" : false, "notGt" : true }
{ "weight" : 7, "gt" : false, "notGt" : true }
{ "weight" : 8, "gt" : false, "notGt" : true }
{ "weight" : 100, "gt" : false, "notGt" : true }
{ "weight" : 130, "gt" : true, "notGt" : false }
{ "weight" : 200, "gt" : true, "notGt" : false }
{ "weight" : 12, "gt" : false, "notGt" : true }
{ "weight" : 30, "gt" : false, "notGt" : true }

Mỗi lần $gt kết quả là true , $not toán tử lật nó thành false . Và mỗi lần $gt dẫn đến false , $not lật nó thành true .