Rechercher un document avec un tableau contenant une valeur spécifique

Si j'ai ce schéma ...

person = {
    name : String,
    favoriteFoods : Array
}

... où le favoriteFoodstableau est rempli de chaînes. Comment puis-je trouver toutes les personnes qui ont des «sushis» comme nourriture préférée en utilisant des mangoustes?

J'espérais quelque chose dans le sens de:

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

(Je sais qu'il n'y en a pas $containsdans mongodb, juste expliquer ce que je m'attendais à trouver avant de connaître la solution)

Comme favouriteFoodsc'est un simple tableau de chaînes, vous pouvez simplement interroger ce champ directement:

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

Mais je recommanderais également de rendre le tableau de chaînes explicite dans votre schéma:

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

La documentation pertinente peut être trouvée ici: https://docs.mongodb.com/manual/tutorial/query-arrays/

Il n'y a aucun $containsopérateur dans mongodb.

Vous pouvez utiliser la réponse de JohnnyHK pendant que cela fonctionne. L'analogie la plus proche de celle que contient mongo est $in, en utilisant cela, votre requête ressemblerait à:

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

Je pense que ce $allserait plus approprié dans cette situation. Si vous cherchez une personne qui aime les sushis, vous faites:

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

Comme vous voudrez peut-être filtrer davantage votre recherche, comme ceci:

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

$inest comme OU et $allcomme ET. Vérifiez ceci: https://docs.mongodb.com/manual/reference/operator/query/all/

Dans le cas où le tableau contient des objets, par exemple, if favouriteFoodsest un tableau d'objets parmi les suivants:

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

vous pouvez utiliser la requête suivante:

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

Si vous avez besoin de trouver des documents contenant des éléments NULL dans un tableau de sous-documents, j'ai trouvé cette requête qui fonctionne plutôt bien:

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

Cette requête est tirée de ce post: tableau de requête MongoDb avec des valeurs nulles

C'était une excellente découverte et cela fonctionne beaucoup mieux que ma propre version initiale et incorrecte (qui s'est avérée fonctionner correctement uniquement pour les tableaux avec un élément):

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

Bien que d'accord avec find () est le plus efficace dans votre cas d'utilisation. Il existe toujours $ match du cadre d'agrégation, pour faciliter la requête d'un grand nombre d'entrées et générer un faible nombre de résultats qui vous tiennent particulièrement à cœur pour le regroupement et la création de nouveaux fichiers.

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

L'incase de lookup_food_array est un tableau.

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

L'incase de lookup_food_array est une chaîne.

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

Pour Loopback3, tous les exemples donnés n'ont pas fonctionné pour moi, ni aussi rapidement que l'utilisation de l'API REST. Mais cela m'a aidé à trouver la réponse exacte dont j'avais besoin.

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

Si vous souhaitez utiliser quelque chose comme un opérateur "contient" via javascript, vous pouvez toujours utiliser une expression régulière pour cela ...

par exemple. Supposons que vous souhaitiez récupérer un client ayant "Bartolomew" comme nom

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);
}

Je sais que ce sujet est ancien, mais pour les futures personnes qui pourraient se poser la même question, une autre solution incroyablement inefficace pourrait être de faire:

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

Cela évite toutes les optimisations par MongoDB donc ne pas utiliser dans le code de production.