Buscar documento con una matriz que contiene un valor específico

Si tengo este esquema ...

person = {
    name : String,
    favoriteFoods : Array
}

... donde la favoriteFoodsmatriz se llena con cadenas. ¿Cómo puedo encontrar a todas las personas que tienen "sushi" como su comida favorita usando mangosta?

Esperaba algo en la línea de:

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

(Sé que no hay $containsmongodb, solo explicando lo que esperaba encontrar antes de conocer la solución)

Como favouriteFoods es una simple matriz de cadenas, puede consultar ese campo directamente:

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

Pero también recomendaría hacer explícito el conjunto de cadenas en su esquema:

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

La documentación relevante se puede encontrar aquí: https://docs.mongodb.com/manual/tutorial/query-arrays/

No hay $containsoperador en mongodb.

Puede usar la respuesta de JohnnyHK ya que funciona. La analogía más cercana a contiene que tiene Mongo es$in , usando esto su consulta se vería así:

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

Siento $allque sería más apropiado en esta situación. Si buscas a una persona que le guste el sushi, lo haces:

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

Como es posible que desee filtrar más su búsqueda, así:

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

$ines como OR y $allcomo AND. Verifique esto: https://docs.mongodb.com/manual/reference/operator/query/all/

En caso de que la matriz contenga objetos, por ejemplo, si favouriteFoodses una matriz de objetos de lo siguiente:

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

puedes usar la siguiente consulta:

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

En caso de que necesite encontrar documentos que contengan elementos NULL dentro de una matriz de subdocumentos, he encontrado esta consulta que funciona bastante bien:

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

Esta consulta está tomada de esta publicación: matriz de consulta MongoDb con valores nulos

Fue un gran hallazgo y funciona mucho mejor que mi propia versión inicial e incorrecta (que resultó funcionar bien solo para matrices con un elemento):

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

Aunque estar de acuerdo con find () es más efectivo en su caso de uso. Todavía hay $ match de marco de agregación, para facilitar la consulta de una gran cantidad de entradas y generar una baja cantidad de resultados que tienen valor para usted, especialmente para agrupar y crear nuevos archivos.

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

En caso de lookup_food_array es matriz.

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

En caso de lookup_food_array es string.

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

Para Loopback3, todos los ejemplos dados no funcionaron para mí, o tan rápido como usar REST API de todos modos. Pero me ayudó a encontrar la respuesta exacta que necesitaba.

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

Si desea usar algo como un operador "contiene" a través de javascript, siempre puede usar una expresión regular para eso ...

p.ej. Digamos que desea recuperar un cliente que tenga "Bartolomew" como nombre

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

Sé que este tema es antiguo, pero para las personas futuras que podrían preguntarse la misma pregunta, otra solución increíblemente ineficiente podría ser:

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

Esto evita todas las optimizaciones de MongoDB, por lo que no debe usarse en el código de producción.