Suchen Sie ein Dokument mit einem Array, das einen bestimmten Wert enthält

Wenn ich dieses Schema habe ...

person = {
    name : String,
    favoriteFoods : Array
}

... wo das favoriteFoodsArray mit Strings gefüllt ist. Wie kann ich mit Mungo alle Personen finden, die "Sushi" als Lieblingsessen haben?

Ich hoffte auf etwas in der Art von:

PersonModel.find({ favoriteFoods : { $contains : "sushi" }, function(...) {...});

(Ich weiß, dass es $containsin Mongodb kein gibt, nur zu erklären, was ich erwartet hatte, bevor ich die Lösung kannte )

Da favouriteFoodses sich um ein einfaches Array von Zeichenfolgen handelt, können Sie dieses Feld einfach direkt abfragen:

PersonModel.find({ favouriteFoods: "sushi" }, ...);

Ich würde aber auch empfehlen, das String-Array in Ihrem Schema explizit zu machen:

person = {
    name : String,
    favouriteFoods : [String]
}

Die entsprechende Dokumentation finden Sie hier: https://docs.mongodb.com/manual/tutorial/query-arrays/

Es gibt keinen $containsOperator in Mongodb.

Sie können die Antwort von JohnnyHK verwenden, da dies funktioniert. Die nächste Analogie zu den Inhalten von Mongo lautet $in: Wenn Sie diese verwenden, würde Ihre Abfrage folgendermaßen aussehen:

PersonModel.find({ favouriteFoods: { "$in" : ["sushi"]} }, ...);

Ich denke, $allwäre in dieser Situation angemessener. Wenn Sie nach einer Person suchen, die Sushi mag, tun Sie Folgendes:

PersonModel.find({ favoriteFood : { $all : ["sushi"] }, ...})

Da Sie Ihre Suche möglicherweise stärker filtern möchten, gehen Sie wie folgt vor:

PersonModel.find({ favoriteFood : { $all : ["sushi", "bananas"] }, ...})

$inist wie ODER und $allwie UND. Überprüfen Sie dies: https://docs.mongodb.com/manual/reference/operator/query/all/

Für den Fall, dass das Array Objekte enthält, z. B. wenn favouriteFoodses sich um ein Array von Objekten der folgenden Art handelt:

{
  name: 'Sushi',
  type: 'Japanese'
}

Sie können die folgende Abfrage verwenden:

PersonModel.find({"favouriteFoods.name": "Sushi"});

Für den Fall, dass Sie Dokumente finden müssen, die NULL-Elemente in einem Array von Unterdokumenten enthalten, habe ich diese Abfrage gefunden, die ziemlich gut funktioniert:

db.collection.find({"keyWithArray":{$elemMatch:{"$in":[null], "$exists":true}}})

Diese Abfrage stammt aus diesem Beitrag: MongoDb-Abfragearray mit Nullwerten

Es war eine großartige Entdeckung und funktioniert viel besser als meine eigene ursprüngliche und falsche Version (die sich nur für Arrays mit einem Element als gut herausstellte):

.find({
    'MyArrayOfSubDocuments': { $not: { $size: 0 } },
    'MyArrayOfSubDocuments._id': { $exists: false }
})

Obwohl Sie mit find () einverstanden sind, ist dies in Ihrem Anwendungsfall am effektivsten. Trotzdem gibt es ein $ match of Aggregation Framework, um die Abfrage einer großen Anzahl von Einträgen zu vereinfachen und eine geringe Anzahl von Ergebnissen zu generieren, die für Sie besonders für das Gruppieren und Erstellen neuer Dateien von Wert sind.

  PersonModel.aggregate([
            { 
                 "$match": { 
                     $and : [{ 'favouriteFoods' : { $exists: true, $in: [ 'sushi']}}, ........ ]  }
             },
             { $project : {"_id": 0, "name" : 1} }
            ]);

Der Fall von lookup_food_array ist ein Array.

match_stage["favoriteFoods"] = {'$elemMatch': {'$in': lookup_food_array}}

Der Fall von lookup_food_array ist eine Zeichenfolge.

match_stage["favoriteFoods"] = {'$elemMatch': lookup_food_string}

Für Loopback3 funktionierten alle angegebenen Beispiele nicht oder so schnell wie die Verwendung der REST-API. Aber es half mir, die genaue Antwort herauszufinden, die ich brauchte.

{"where":{"arrayAttribute":{ "all" :[String]}}}

Wenn Sie so etwas wie einen "enthält" -Operator über Javascript verwenden möchten, können Sie dafür immer einen regulären Ausdruck verwenden ...

z.B. Angenommen, Sie möchten einen Kunden mit dem Namen "Bartolomew" abrufen

async function getBartolomew() {
    const custStartWith_Bart = await Customers.find({name: /^Bart/ }); // Starts with Bart
    const custEndWith_lomew = await Customers.find({name: /lomew$/ }); // Ends with lomew
    const custContains_rtol = await Customers.find({name: /.*rtol.*/ }); // Contains rtol

    console.log(custStartWith_Bart);
    console.log(custEndWith_lomew);
    console.log(custContains_rtol);
}

Ich weiß, dass dieses Thema alt ist, aber für zukünftige Leute, die sich die gleiche Frage stellen könnten, könnte eine andere unglaublich ineffiziente Lösung sein:

PersonModel.find({$where : 'this.favouriteFoods.indexOf("sushi") != -1'});

Dies vermeidet alle Optimierungen durch MongoDB und wird daher nicht im Produktionscode verwendet.