MongoDB $not Aggregation Pipeline Operator

In MongoDB ist das $not Der Aggregations-Pipeline-Operator wertet einen booleschen Wert aus und gibt den entgegengesetzten booleschen Wert zurück.

Mit anderen Worten, wenn der boolesche Wert true ergibt , das $not Operator gibt false zurück . Und wenn der boolesche Wert false ergibt , das $not Operator gibt true zurück .

Beispiel

Angenommen, wir haben eine Sammlung namens tests mit folgenden Dokumenten:

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

Folgendes passiert, wenn wir $not anwenden zu den data Feld jedes Dokuments:

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

Ergebnis:

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

Wir können sehen, dass $not gab das Gegenteil von jedem booleschen Wert zurück.

Null, Null und undefinierte Werte

Das $not Operator wertet 0 aus , null , und undefined als false – was bedeutet, dass es true zurückgibt .

Angenommen, wir haben die folgenden Dokumente:

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

Folgendes passiert, wenn wir $not anwenden :

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

Ergebnis:

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

Wie erwartet gaben sie alle true zurück (was bedeutet, dass sie als false ausgewertet wurden .

Alle anderen Werte

Das $not Operator alle anderen Werte als true – was bedeutet, dass es false zurückgibt .

Angenommen, wir haben die folgenden Dokumente:

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

Folgendes passiert, wenn wir $not anwenden :

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

Ergebnis:

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

Sie alle geben false zurück (was bedeutet, dass sie zu true ausgewertet werden ).

Fehlende Felder

Anwenden von $not zu einem Feld, das nicht existiert, ergibt false (was bedeutet, dass es true zurückgibt ).

Angenommen, wir haben das folgende Dokument:

{ "_id" : 11 }

Und wir wenden $not an dazu:

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

Ergebnis:

{ "result" : true }

Negiere einen anderen Operator

Das $not operator kann verwendet werden, um die boolesche Ausgabe eines anderen Operators zu negieren.

Angenommen, wir haben eine Sammlung namens pets mit folgenden Dokumenten:

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

Wir können $not verwenden in Verbindung mit beispielsweise $gt um das Gewichtsfeld auszuwerten:

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

Ergebnis:

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

Um dies zu wiederholen, hier ist es noch einmal, aber dieses Mal geben wir ein Feld für $gt aus Ergebnisse sowie das Feld für nicht $gt Ergebnisse:

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

Ergebnis:

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

Jedes Mal $gt ergab true , das $not Operator hat es auf false umgedreht . Und jedes Mal $gt ergab false , $not hat es auf true umgedreht .