Puedes consultar arreglos en MongoDB utilizando los siguientes métodos:
El driver de su lenguaje de programación.
La Interfaz de usuario de MongoDB Atlas. Para obtener más información, consulte Consultar una matriz con MongoDB Atlas.
➤ Use el menú desplegable Seleccionar su lenguaje en la parte superior derecha para establecer el lenguaje de los siguientes ejemplos o seleccione MongoDB Compass.
Esta página ofrece ejemplos de operaciones de query en campos de arreglo utilizando el
db.collection.find() método en mongosh.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
En esta página, se proporcionan ejemplos de operaciones de query en campos de arreglos mediante MongoDB Compass.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
Esta página ofrece ejemplos de operaciones de query en campos de arrays usando mongoc_collection_find_with_opts.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
Esta página proporciona ejemplos de operaciones de query en campos de arreglo utilizando el método MongoCollection.Find() en el MongoDB C# Driver.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
Esta página proporciona ejemplos de operaciones de query en campos de arreglo utilizando la función Collection.Find en el MongoDB Go Driver.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
Esta página proporciona ejemplos de operaciones de query sobre campos de arreglo utilizando el método com.mongodb.reactivestreams.client.MongoCollection.find en el controlador Java Reactive Streams de MongoDB.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
Esta página proporciona ejemplos de operaciones de query en campos de arreglos utilizando el método com.mongodb.client.MongoCollection.find en el controlador síncrono de Java de MongoDB.
Tip
El driver ofrece métodos asistentes com.mongodb.client.model.Filters para facilitar la creación de documentos de filtro. Los ejemplos en esta página utilizan estos métodos para crear los documentos de filtro.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
Esta página proporciona ejemplos de operaciones de query en campos de arreglos utilizando el método MongoCollection.find() en el controlador de corrutinas de Kotlin para MongoDB.
Tip
El driver ofrece métodos asistentes com.mongodb.client.model.Filters para facilitar la creación de documentos de filtro. Los ejemplos en esta página utilizan estos métodos para crear los documentos de filtro.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
A partir de mayo de 14, 2025, Motor está obsoleto en favor de la versión GA de la API asíncrona de PyMongo en la librería PyMongo. No añadiremos nuevas características a Motor, y solo proporcionaremos correcciones de errores hasta que llegue al final de su vida útil el 14 de mayo de 2026. Después de eso, solo corregiremos los errores críticos hasta que finalice el soporte el 14 de mayo de 2027. Recomendamos encarecidamente migrar a la API asíncrona de PyMongo mientras Motor aún sea compatible.
Para obtener más información sobre la migración, consulta la Guía de migración a PyMongo asíncrono en la documentación de PyMongo.
Esta página proporciona ejemplos de operaciones de consulta en campos de matriz utilizando el método en la API pymongo.asynchronous.collection.AsyncCollection.find asíncrona de PyMongo.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
Esta página proporciona ejemplos de operaciones de query en campos de arreglos usando el método Collection.find() en el MongoDB Node.js Driver.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
En esta página, se proporcionan ejemplos de operaciones de query en campos de arreglo mediante el método MongoDB\\Collection::find() en la Librería PHP de MongoDB.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
Esta página proporciona ejemplos de operaciones de query en campos de arreglo utilizando el método pymongo.collection.Collection.find en el controlador de Python PyMongo.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
Esta página proporciona ejemplos de operaciones de query en campos de arreglo utilizando el método Mongo::Collection#find() en el MongoDB Ruby Driver.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
Esta página proporciona ejemplos de operaciones de query en campos de arreglo utilizando el método collection.find() en el MongoDB Scala Driver.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
db.inventory.insertMany([ { item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] }, { item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] }, { item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] }, { item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] }, { item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] } ]);
[ { "item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [ 14, 21 ] }, { "item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [ 14, 21 ] }, { "item": "paper", "qty": 100, "tags": ["red", "blank", "plain"], "dim_cm": [ 14, 21 ] }, { "item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [ 22.85, 30 ] }, { "item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [ 10, 15.25 ] } ]
Para obtener instrucciones sobre cómo insertar documentos en MongoDB Compass, consulta Insertar documentos.
mongoc_collection_t *collection; mongoc_bulk_operation_t *bulk; bson_t *doc; bool r; bson_error_t error; bson_t reply; collection = mongoc_database_get_collection (db, "inventory"); bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL); doc = BCON_NEW ( "item", BCON_UTF8 ("journal"), "qty", BCON_INT64 (25), "tags", "[", BCON_UTF8 ("blank"), BCON_UTF8 ("red"), "]", "dim_cm", "[", BCON_INT64 (14), BCON_INT64 (21), "]"); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("notebook"), "qty", BCON_INT64 (50), "tags", "[", BCON_UTF8 ("red"), BCON_UTF8 ("blank"), "]", "dim_cm", "[", BCON_INT64 (14), BCON_INT64 (21), "]"); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("paper"), "qty", BCON_INT64 (100), "tags", "[", BCON_UTF8 ("red"), BCON_UTF8 ("blank"), BCON_UTF8 ("plain"), "]", "dim_cm", "[", BCON_INT64 (14), BCON_INT64 (21), "]"); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("planner"), "qty", BCON_INT64 (75), "tags", "[", BCON_UTF8 ("blank"), BCON_UTF8 ("red"), "]", "dim_cm", "[", BCON_DOUBLE (22.85), BCON_INT64 (30), "]"); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("postcard"), "qty", BCON_INT64 (45), "tags", "[", BCON_UTF8 ("blue"), "]", "dim_cm", "[", BCON_INT64 (10), BCON_DOUBLE (15.25), "]"); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } /* "reply" is initialized on success or error */ r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error); if (!r) { MONGOC_ERROR ("%s\n", error.message); }
var documents = new[] { new BsonDocument { { "item", "journal" }, { "qty", 25 }, { "tags", new BsonArray { "blank", "red" } }, { "dim_cm", new BsonArray { 14, 21 } } }, new BsonDocument { { "item", "notebook" }, { "qty", 50 }, { "tags", new BsonArray { "red", "blank" } }, { "dim_cm", new BsonArray { 14, 21 } } }, new BsonDocument { { "item", "paper" }, { "qty", 100 }, { "tags", new BsonArray { "red", "blank", "plain" } }, { "dim_cm", new BsonArray { 14, 21 } } }, new BsonDocument { { "item", "planner" }, { "qty", 75 }, { "tags", new BsonArray { "blank", "red" } }, { "dim_cm", new BsonArray { 22.85, 30 } } }, new BsonDocument { { "item", "postcard" }, { "qty", 45 }, { "tags", new BsonArray { "blue" } }, { "dim_cm", new BsonArray { 10, 15.25 } } } }; collection.InsertMany(documents);
docs := []any{ bson.D{ {"item", "journal"}, {"qty", 25}, {"tags", bson.A{"blank", "red"}}, {"dim_cm", bson.A{14, 21}}, }, bson.D{ {"item", "notebook"}, {"qty", 50}, {"tags", bson.A{"red", "blank"}}, {"dim_cm", bson.A{14, 21}}, }, bson.D{ {"item", "paper"}, {"qty", 100}, {"tags", bson.A{"red", "blank", "plain"}}, {"dim_cm", bson.A{14, 21}}, }, bson.D{ {"item", "planner"}, {"qty", 75}, {"tags", bson.A{"blank", "red"}}, {"dim_cm", bson.A{22.85, 30}}, }, bson.D{ {"item", "postcard"}, {"qty", 45}, {"tags", bson.A{"blue"}}, {"dim_cm", bson.A{10, 15.25}}, }, } result, err := coll.InsertMany(context.TODO(), docs)
Publisher<Success> insertManyPublisher = collection.insertMany(asList( Document.parse("{ item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [ 14, 21 ] }"), Document.parse("{ item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [ 14, 21 ] }"), Document.parse("{ item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [ 14, 21 ] }"), Document.parse("{ item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [ 22.85, 30 ] }"), Document.parse("{ item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [ 10, 15.25 ] }") ));
collection.insertMany(asList( Document.parse("{ item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [ 14, 21 ] }"), Document.parse("{ item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [ 14, 21 ] }"), Document.parse("{ item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [ 14, 21 ] }"), Document.parse("{ item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [ 22.85, 30 ] }"), Document.parse("{ item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [ 10, 15.25 ] }") ));
collection.insertMany( listOf( Document("item", "journal") .append("qty", 25) .append("tags", listOf("blank", "red")) .append("dim_cm", listOf(14, 21)), Document("item", "notebook") .append("qty", 50) .append("tags", listOf("red", "blank")) .append("dim_cm", listOf(14, 21)), Document("item", "paper") .append("qty", 100) .append("tags", listOf("red", "blank", "plain")) .append("dim_cm", listOf(14, 21)), Document("item", "planner") .append("qty", 75) .append("tags", listOf("blank", "red")) .append("dim_cm", listOf(22.85, 30)), Document("item", "postcard") .append("qty", 45) .append("tags", listOf("blue")) .append("dim_cm", listOf(10, 15.25)), ) )
await db.inventory.insert_many( [ {"item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [14, 21]}, {"item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [14, 21]}, { "item": "paper", "qty": 100, "tags": ["red", "blank", "plain"], "dim_cm": [14, 21], }, {"item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [22.85, 30]}, {"item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [10, 15.25]}, ] )
await db.collection('inventory').insertMany([ { item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [14, 21] }, { item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [14, 21] }, { item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [14, 21] }, { item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [22.85, 30] }, { item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [10, 15.25] } ]);
$insertManyResult = $db->inventory->insertMany([ [ 'item' => 'journal', 'qty' => 25, 'tags' => ['blank', 'red'], 'dim_cm' => [14, 21], ], [ 'item' => 'notebook', 'qty' => 50, 'tags' => ['red', 'blank'], 'dim_cm' => [14, 21], ], [ 'item' => 'paper', 'qty' => 100, 'tags' => ['red', 'blank', 'plain'], 'dim_cm' => [14, 21], ], [ 'item' => 'planner', 'qty' => 75, 'tags' => ['blank', 'red'], 'dim_cm' => [22.85, 30], ], [ 'item' => 'postcard', 'qty' => 45, 'tags' => ['blue'], 'dim_cm' => [10, 15.25], ], ]);
db.inventory.insert_many( [ {"item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [14, 21]}, {"item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [14, 21]}, { "item": "paper", "qty": 100, "tags": ["red", "blank", "plain"], "dim_cm": [14, 21], }, {"item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [22.85, 30]}, {"item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [10, 15.25]}, ] )
client[:inventory].insert_many([ { item: 'journal', qty: 25, tags: %w[blank red], dim_cm: [ 14, 21 ] }, { item: 'notebook', qty: 50, tags: %w[red blank], dim_cm: [ 14, 21 ] }, { item: 'paper', qty: 100, tags: %w[red blank plain], dim_cm: [ 14, 21 ] }, { item: 'planner', qty: 75, tags: %w[blank red], dim_cm: [ 22.85, 30 ] }, { item: 'postcard', qty: 45, tags: [ 'blue' ], dim_cm: [ 10, 15.25 ] } ])
collection.insertMany(Seq( Document("""{ item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] }"""), Document("""{ item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] }"""), Document("""{ item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] }"""), Document("""{ item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] }"""), Document("""{ item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] }""") )).execute()
Hacer coincidir un arreglo
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar una condición de igualdad en un arreglo, construye un filtro utilizando el método Eq, en el que <value> es el arreglo exacto a coincidir, incluyendo el orden de los elementos:
Builders<BsonDocument>.Filter.Eq(<field>, <value>)
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query eq( <field>, <value>) donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query eq( <field>, <value>) donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query [ <field> => <value> ] donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field> => <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query equal( <field>, <value> ) donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
El siguiente ejemplo consulta todos los documentos donde tags es un arreglo con exactamente dos elementos, "red" y "blank", en el orden especificado:
db.inventory.find( { tags: ["red", "blank"] } )
Copia el siguiente filtro en la barra de query de Compass y haz clic Find:
{ tags: ["red", "blank"] }
mongoc_collection_t *collection; bson_t *filter; mongoc_cursor_t *cursor; collection = mongoc_database_get_collection (db, "inventory"); filter = BCON_NEW ( "tags", "[", BCON_UTF8 ("red"), BCON_UTF8 ("blank"), "]"); cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("tags", new[] { "red", "blank" }); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{{"tags", bson.A{"red", "blank"}}}, )
FindPublisher<Document> findPublisher = collection.find(eq("tags", asList("red", "blank")));
FindIterable<Document> findIterable = collection.find(eq("tags", asList("red", "blank")));
val findFlow = collection .find(eq("tags", listOf("red", "blank")))
cursor = db.inventory.find({"tags": ["red", "blank"]})
const cursor = db.collection('inventory').find({ tags: ['red', 'blank'] });
$cursor = $db->inventory->find(['tags' => ['red', 'blank']]);
cursor = db.inventory.find({"tags": ["red", "blank"]})
client[:inventory].find(tags: %w[red blank])
var findObservable = collection.find(equal("tags", Seq("red", "blank")))
Para encontrar un arreglo que contenga tanto "red" como "blank", independientemente del orden u otros elementos en el arreglo, utiliza el operador $all :
db.inventory.find( { tags: { $all: ["red", "blank"] } } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ tags: { $all: ["red", "blank"] } }
mongoc_collection_t *collection; bson_t *filter; mongoc_cursor_t *cursor; collection = mongoc_database_get_collection (db, "inventory"); filter = BCON_NEW ( "tags", "{", "$all", "[", BCON_UTF8 ("red"), BCON_UTF8 ("blank"), "]", "}"); cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.All("tags", new[] { "red", "blank" }); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"tags", bson.D{{"$all", bson.A{"red", "blank"}}}}, })
findPublisher = collection.find(all("tags", asList("red", "blank")));
findIterable = collection.find(all("tags", asList("red", "blank")));
val findFlow = collection .find(all("tags", listOf("red", "blank")))
cursor = db.inventory.find({"tags": {"$all": ["red", "blank"]}})
const cursor = db.collection('inventory').find({ tags: { $all: ['red', 'blank'] } });
$cursor = $db->inventory->find(['tags' => ['$all' => ['red', 'blank']]]);
cursor = db.inventory.find({"tags": {"$all": ["red", "blank"]}})
client[:inventory].find(tags: { '$all' => %w[red blank] })
findObservable = collection.find(all("tags", "red", "blank"))
Consultar un arreglo para un elemento
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro { <field>: <value> } donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro { <field>: <value> } donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro { <field>: <value> } donde <value> es el valor del elemento.
Para hacer una query si el campo de arreglo contiene al menos un elemento con el valor especificado, construye un filtro utilizando el método Eq, en el que <value> es el valor del elemento a coincidir:
Builders<BsonDocument>.Filter.Eq(<field>, <value>)
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro eq( <field>, <value>) donde <value> es el valor del elemento.
Para consultar si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro eq( <field>, <value>) donde el valor es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro eq( <field>, <value>) donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro eq( <field>, <value>) donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro { <field>: <value> } donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro { <field>: <value> } donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro [ <field> => <value> ] donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro { <field>: <value> } donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro { <field> => <value> } donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro equal( <field>, <value> ) donde <value> es el valor del elemento.
El siguiente ejemplo consulta todos los documentos donde el arreglo tags contiene la cadena "red" como uno de sus elementos:
db.inventory.find( { tags: "red" } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ tags: "red" }
mongoc_collection_t *collection; bson_t *filter; mongoc_cursor_t *cursor; collection = mongoc_database_get_collection (db, "inventory"); filter = BCON_NEW ("tags", BCON_UTF8 ("red")); cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.Eq("tags", "red"); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"tags", "red"}, })
findPublisher = collection.find(eq("tags", "red"));
findIterable = collection.find(eq("tags", "red"));
val findFlow = collection .find(eq("tags", "red"))
cursor = db.inventory.find({"tags": "red"})
const cursor = db.collection('inventory').find({ tags: 'red' });
$cursor = $db->inventory->find(['tags' => 'red']);
cursor = db.inventory.find({"tags": "red"})
client[:inventory].find(tags: 'red')
findObservable = collection.find(equal("tags", "red"))
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
Para especificar condiciones en los elementos del campo de arreglo, utiliza operadores del query en el documento de filtro de query. Por ejemplo:
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<array field>, <value1>), builder.Lt(<array field>, <value2>));
Para especificar condiciones en los elementos del campo de arreglo, utiliza operadores del query en el documento de filtro de query. Por ejemplo:
filter := bson.D{ {"$and", bson.A{ bson.D{{<array field>, bson.D{{"$eq", <value1>}}}}, bson.D{{<array field>, bson.D{{"$lt", <value2>}}}}, }}, }
Para especificar condiciones en los elementos del campo de arreglo, utiliza operadores del query en el documento de filtro de query. Por ejemplo:
and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)
Para especificar condiciones en los elementos del campo de arreglo, utiliza operadores del query en el documento de filtro de query. Por ejemplo:
and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)
Para especificar condiciones en los elementos del campo de arreglo, utiliza operadores del query en el documento de filtro de query. Por ejemplo:
and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
[ <array field> => [ <operator1> => <value1>, ... ] ]
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field> => { <operator1> => <value1>, ... } }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)
El siguiente ejemplo realiza una consulta por todos los documentos donde el arreglo dim_cm contiene al menos un elemento cuyo valor es mayor que 25:
db.inventory.find( { dim_cm: { $gt: 25 } } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ dim_cm: { $gt: 25 } }
mongoc_collection_t *collection; bson_t *filter; mongoc_cursor_t *cursor; collection = mongoc_database_get_collection (db, "inventory"); filter = BCON_NEW ( "dim_cm", "{", "$gt", BCON_INT64 (25), "}"); cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.Gt("dim_cm", 25); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"dim_cm", bson.D{ {"$gt", 25}, }}, })
findPublisher = collection.find(gt("dim_cm", 25));
findIterable = collection.find(gt("dim_cm", 25));
val findFlow = collection .find(gt("dim_cm", 25))
cursor = db.inventory.find({"dim_cm": {"$gt": 25}})
const cursor = db.collection('inventory').find({ dim_cm: { $gt: 25 } });
$cursor = $db->inventory->find(['dim_cm' => ['$gt' => 25]]);
cursor = db.inventory.find({"dim_cm": {"$gt": 25}})
client[:inventory].find(dim_cm: { '$gt' => 25 })
findObservable = collection.find(gt("dim_cm", 25))
Especifica múltiples condiciones para los elementos del arreglo
Cuando especifica condiciones compuestas en elementos de un arreglo, puede consultar documentos donde:
Un solo elemento de la matriz cumple todas las condiciones especificadas
Los diferentes elementos de la matriz cumplen colectivamente todas las condiciones, y cada elemento satisface una o más condiciones.
Consulta un arreglo con condiciones de filtro compuesto sobre los elementos del arreglo
El siguiente ejemplo query para documentos donde el arreglo dim_cm contiene elementos que, en alguna combinación, satisfacen las condiciones de la query. Un elemento puede cumplir con la condición mayor que 15 y otro elemento puede cumplir con la condición menor que 20, o un solo elemento puede cumplir con ambas:
db.inventory.find( { dim_cm: { $gt: 15, $lt: 20 } } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ dim_cm: { $gt: 15, $lt: 20 } }
mongoc_collection_t *collection; bson_t *filter; mongoc_cursor_t *cursor; collection = mongoc_database_get_collection (db, "inventory"); filter = BCON_NEW ( "dim_cm", "{", "$gt", BCON_INT64 (15), "$lt", BCON_INT64 (20), "}"); cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var builder = Builders<BsonDocument>.Filter; var filter = builder.And(builder.Gt("dim_cm", 15), builder.Lt("dim_cm", 20)); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"dim_cm", bson.D{ {"$gt", 15}, {"$lt", 20}, }}, })
findPublisher = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)));
findIterable = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)));
val findFlow = collection .find(and(gt("dim_cm", 15), lt("dim_cm", 20)))
cursor = db.inventory.find({"dim_cm": {"$gt": 15, "$lt": 20}})
const cursor = db.collection('inventory').find({ dim_cm: { $gt: 15, $lt: 20 } });
$cursor = $db->inventory->find([ 'dim_cm' => [ '$gt' => 15, '$lt' => 20, ], ]);
cursor = db.inventory.find({"dim_cm": {"$gt": 15, "$lt": 20}})
client[:inventory].find(dim_cm: { '$gt' => 15, '$lt' => 20 })
findObservable = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)))
Query para un elemento de arreglo que cumpla con varios criterios
Usa el operador $elemMatch para especificar múltiples criterios en los elementos de un arreglo, de modo que al menos un elemento del arreglo cumpla todos los criterios especificados.
El siguiente ejemplo consulta documentos donde el arreglo dim_cm contiene al menos un elemento que es mayor que ($gt) 22 y menor que ($lt) 30:
db.inventory.find( { dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } }
mongoc_collection_t *collection; bson_t *filter; mongoc_cursor_t *cursor; collection = mongoc_database_get_collection (db, "inventory"); filter = BCON_NEW ( "dim_cm", "{", "$elemMatch", "{", "$gt", BCON_INT64 (22), "$lt", BCON_INT64 (30), "}", "}"); cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("dim_cm", new BsonDocument { { "$gt", 22 }, { "$lt", 30 } }); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"dim_cm", bson.D{ {"$elemMatch", bson.D{ {"$gt", 22}, {"$lt", 30}, }}, }}, })
findPublisher = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));
findIterable = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));
val findFlow = collection .find(elemMatch("dim_cm", Document.parse("{ \$gt: 22, \$lt: 30 }")))
cursor = db.inventory.find({"dim_cm": {"$elemMatch": {"$gt": 22, "$lt": 30}}})
const cursor = db.collection('inventory').find({ dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } });
$cursor = $db->inventory->find([ 'dim_cm' => [ '$elemMatch' => [ '$gt' => 22, '$lt' => 30, ], ], ]);
cursor = db.inventory.find({"dim_cm": {"$elemMatch": {"$gt": 22, "$lt": 30}}})
client[:inventory].find(dim_cm: { '$elemMatch' => { '$gt' => 22, '$lt' => 30 } })
findObservable = collection.find(elemMatch("dim_cm", Document("$gt" -> 22, "$lt" -> 30)))
Query para un elemento por la posición del índice del arreglo
Utilice la notación de puntos para especificar las condiciones de consulta de un elemento en un índice o posición específicos del array. El array utiliza indexación basada en cero.
Nota
Cuando realices queries utilizando la notación de puntos, el campo y el subcampo anidado deben estar entre comillas.
El siguiente ejemplo del query para todos los documentos donde el segundo elemento del arreglo dim_cm es mayor que 25:
db.inventory.find( { "dim_cm.1": { $gt: 25 } } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ "dim_cm.1": { $gt: 25 } }
mongoc_collection_t *collection; bson_t *filter; mongoc_cursor_t *cursor; collection = mongoc_database_get_collection (db, "inventory"); filter = BCON_NEW ( "dim_cm.1", "{", "$gt", BCON_INT64 (25), "}"); cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.Gt("dim_cm.1", 25); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"dim_cm.1", bson.D{ {"$gt", 25}, }}, })
findPublisher = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));
findIterable = collection.find(gt("dim_cm.1", 25));
val findFlow = collection .find(gt("dim_cm.1", 25))
cursor = db.inventory.find({"dim_cm.1": {"$gt": 25}})
const cursor = db.collection('inventory').find({ 'dim_cm.1': { $gt: 25 } });
$cursor = $db->inventory->find(['dim_cm.1' => ['$gt' => 25]]);
cursor = db.inventory.find({"dim_cm.1": {"$gt": 25}})
client[:inventory].find('dim_cm.1' => { '$gt' => 25 })
findObservable = collection.find(gt("dim_cm.1", 25))
Consulta un arreglo por longitud de arreglo
Utiliza el operador $size para consultar arreglos por número de elementos. El siguiente ejemplo selecciona documentos donde tags tiene 3 elementos:
db.inventory.find( { "tags": { $size: 3 } } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ "tags": { $size: 3 } }
mongoc_collection_t *collection; bson_t *filter; mongoc_cursor_t *cursor; collection = mongoc_database_get_collection (db, "inventory"); filter = BCON_NEW ( "tags", "{", "$size", BCON_INT64 (3), "}"); cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
Limpia cualquier recurso abierto llamando a los siguientes métodos, según corresponda:
var filter = Builders<BsonDocument>.Filter.Size("tags", 3); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"tags", bson.D{ {"$size", 3}, }}, })
findPublisher = collection.find(size("tags", 3));
findIterable = collection.find(size("tags", 3));
val findFlow = collection .find(size("tags", 3))
cursor = db.inventory.find({"tags": {"$size": 3}})
const cursor = db.collection('inventory').find({ tags: { $size: 3 } });
$cursor = $db->inventory->find(['tags' => ['$size' => 3]]);
cursor = db.inventory.find({"tags": {"$size": 3}})
client[:inventory].find(tags: { '$size' => 3 })
findObservable = collection.find(size("tags", 3))
Consulta un arreglo con MongoDB Atlas
El ejemplo en esta sección utiliza el conjunto de datos de películas de muestra. Para aprender a cargar el conjunto de datos de muestra en la implementación de MongoDB Atlas, se debe consultar Cargar datos de muestra.
Para consultar un arreglo en MongoDB Atlas, sigue estos pasos:
En la interfaz de usuario de MongoDB Atlas, ve a la página Clusters de tu proyecto.
Si aún no se muestra, seleccione la organización que contiene su proyecto deseado en el menú Organizations de la barra de navegación.
Si aún no se muestra, seleccione su proyecto en el menú Projects de la barra de navegación.
En la barra lateral, haz clic en Clusters en la sección Database.
La página de clústeres se muestra.
Especifica un documento de filtro de query.
Para consultar un documento que contiene un arreglo, especifique un documento de filtro de query. Un operadores del query utiliza un documento de filtro de query para especificar las condiciones de búsqueda. Utilice los siguientes documentos de ejemplo para query los campos de arreglo en la colección sample_mflix.movies.
Para aplicar un filtro de query, copiar un documento de ejemplo en la barra de búsqueda Filter y hacer clic en Apply.
Para especificar una condición de igualdad en un arreglo, usa el documento de consulta { <field>: <value> }, donde <value> es el arreglo exacto que se debe coincidir, incluido el orden de los elementos. El siguiente ejemplo encuentra documentos donde genres contiene el arreglo ["Action", "Comedy"] en el orden especificado:
{ genres: ["Action", "Comedy"] }
Para encontrar un arreglo que contenga tanto Action como Comedy, independientemente del orden u otros elementos en el arreglo, utiliza el operador $all :
{ genres: { $all: ["Action", "Comedy"] } }
Para realizar un query si el campo del arreglo contiene al menos un elemento con el valor especificado, utiliza el filtro { <field>: <value> } donde <value> es el valor del elemento.
En el siguiente ejemplo, se realiza un query por todos los documentos donde el campo genres contiene el string Short como uno de sus elementos:
{ genres: "Short" }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
El siguiente ejemplo utiliza el operador para consultar todos los documentos donde $nin el genres campo no Drama contiene:
{ genres: { $nin: ["Drama"] } }
Al especificar condiciones compuestas sobre elementos de un arreglo, puede query por un único elemento del arreglo que cumpla todas las condiciones o por cualquier combinación de elementos del arreglo que, en conjunto, cumplan las condiciones.
Consulta un arreglo con condiciones de filtro compuesto sobre los elementos del arreglo
En el siguiente ejemplo se consultan documentos donde el arreglo cast contiene elementos que en combinación satisfacen las condiciones de la query. El siguiente filtro utiliza los operadores $regex y $eq para devolver documentos en los que un solo elemento de arreglo termina en Olsen y otro elemento es igual a Mary-Kate Olsen o un solo elemento que cumpla ambas condiciones:
{ cast: { $regex: "Olsen$", $eq: "Mary-Kate Olsen" } }
Este filtro de query devuelve películas que incluyen a Mary-Kate
Olsen en su reparto, y películas que incluyen tanto a Mary-Kate Olsen como a Ashley Olsen en su reparto.
Query para un elemento de arreglo que cumpla con varios criterios
Usa el operador $elemMatch para especificar varios criterios en los elementos de un arreglo, de modo que al menos un elemento del arreglo cumpla con todos los criterios especificados.
El siguiente ejemplo utiliza los operadores $elemMatch y $ne para consultar documentos en los que languages contiene al menos un elemento que no es null y no equivale a English:
{ languages: { $elemMatch: { $ne: null, $ne: "English" } } }
Query para un elemento por la posición del índice del arreglo
Utilice la notación de puntos para especificar las condiciones de consulta de un elemento en un índice o posición específicos del array. El array utiliza indexación basada en cero.
Nota
Cuando realices queries utilizando la notación de puntos, el campo y el subcampo anidado deben estar entre comillas.
En el siguiente ejemplo, se utiliza el operador $ne para realizar un query por todos los documentos donde el primer elemento en el arreglo countries no es igual a USA:
{ "countries.0": { $ne: "USA" } }
Consulta un arreglo por longitud de arreglo
Utiliza el operador $size para consultar arreglos por número de elementos. El siguiente ejemplo selecciona documentos donde genres tiene 3 elementos:
{ genres: { $size: 3 } }
Tutoriales adicionales de query
Para obtener ejemplos adicionales de queries, consulte: