/ /

/ /

$eq

$eq: Especifica la condición de igualdad. El $eq El operador coincide con documentos donde el valor de un campo es igual al valor especificado.

Compatibilidad

Puedes usar $eq para implementaciones alojadas en los siguientes entornos:

MongoDB Atlas: El servicio totalmente gestionado para implementaciones de MongoDB en la nube

MongoDB Enterprise: La versión basada en suscripción y autogestionada de MongoDB
MongoDB Community: La versión de MongoDB con código fuente disponible, de uso gratuito y autogestionada.

Sintaxis

El operador $eq tiene el siguiente formato:

{ <field>: { $eq: <value> } }

El $eq operador es equivalente a la { field: <value> } forma, excepto cuando <value> es una expresión regular. Vea ejemplos a continuación.

Comportamiento

Orden de comparación

Para la comparación de diferentes valores de tipo BSON, consulta el orden de comparación especificado de BSON.

Coincidir un valor de documento

Si <value> es un documento, el orden de los campos en el documento es importante.

Hacer coincidir un valor de un arreglo

Si <value> es un array, MongoDB busca documentos donde <field> coincida exactamente con el array o <field> contenga un elemento que coincida exactamente con el array. El orden de los elementos es importante. Para ver un ejemplo, consulte "Es igual a un valor de array".

Coincidir una expresión regular

La expresión { field: <value> } especifica implícitamente una coincidencia en <value>. MongoDB traduce la coincidencia implícita a una forma más explícita.

Cuando <value> es fijo, como una cadena particular, la expresión es equivalente a utilizar el operador $eq { field: { $eq: <value> } }.

Si <value> es una expresión regular, MongoDB expande la declaración para utilizar el operador $regex { field: { $regex: <value> } }.

Para ejemplos, consulta Comportamiento de coincidencia de expresiones regulares.

Implicaciones de seguridad

Utiliza siempre la forma explícita { field: { $eq: <value> } } con la entrada proporcionada por el usuario para evitar problemas con queries formadas de manera maliciosa.

Ejemplos

Los ejemplos utilizan la colección inventory:

db.inventory.insertMany( [
   { _id: 1, item: { name: "ab", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] },
   { _id: 2, item: { name: "cd", code: "123" }, qty: 20, tags: [ "B" ] },
   { _id: 3, item: { name: "ij", code: "456" }, qty: 25, tags: [ "A", "B" ] },
   { _id: 4, item: { name: "xy", code: "456" }, qty: 30, tags: [ "B", "A" ] },
   { _id: 5, item: { name: "mn", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }
] )

Es igual a un valor especificado

Este ejemplo selecciona todos los documentos de la colección inventory donde el valor del campo qty es igual a 20:

db.inventory.find( { qty: { $eq: 20 } } )

La query es equivalente a:

db.inventory.find( { qty: 20 } )

Ambas queries coinciden con los siguientes documentos:

[
   { _id: 2, item: { name: "cd", code: "123" }, qty: 20, tags: [ "B" ] },
   { _id: 5, item: { name: "mn", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }
]

El campo en un documento incrustado es igual a un valor

El siguiente ejemplo selecciona todos los documentos de la inventory colección donde el item.name valor del campo "ab" es. Para especificar una condición en un campo de un documento incrustado, utilice la notación de punto.

db.inventory.find( { "item.name": { $eq: "ab" } } )

La query es equivalente a:

db.inventory.find( { "item.name": "ab" } )

Ambas queries coinciden con el siguiente documento:

[ { _id: 1, item: { name: "ab", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } ]

Tip

Consulta documentos incrustados

El elemento de arreglo es igual a un valor

El siguiente ejemplo selecciona todos los documentos de la inventory colección donde la tags matriz contiene un elemento con el valor "B" []:1

db.inventory.find( { tags: { $eq: "B" } } )

La query es equivalente a:

db.inventory.find( { tags: "B" } )

Ambas queries coinciden con los siguientes documentos:

[
   { _id: 1, item: { name: "ab", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] },
   { _id: 2, item: { name: "cd", code: "123" }, qty: 20, tags: [ "B" ] },
   { _id: 3, item: { name: "ij", code: "456" }, qty: 25, tags: [ "A", "B" ] },
   { _id: 4, item: { name: "xy", code: "456" }, qty: 30, tags: [ "B", "A" ] }
]

Tip

[1]	La query también coincidirá con documentos donde el valor del campo `tags` es la string `"B"`.

Es igual a un valor de arreglo

Este ejemplo selecciona todos los documentos de la colección inventory donde la matriz tags es igual a la matriz especificada o contiene un elemento que es igual a la matriz [ "A", "B" ].

db.inventory.find( { tags: { $eq: [ "A", "B" ] } } )

La query es equivalente a:

db.inventory.find( { tags: [ "A", "B" ] } )

Ambas queries coinciden con los siguientes documentos:

[
   { _id: 3, item: { name: "ij", code: "456" }, qty: 25, tags: [ "A", "B" ] },
   { _id: 5, item: { name: "mn", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }
]

Comportamiento de coincidencia de expresiones regulares

Los siguientes ejemplos muestran la diferencia entre la coincidencia implícita y explícita de expresiones regulares. Considera una colección con estos documentos:

db.companies.insertMany( [
   { _id: 001, company: "MongoDB" },
   { _id: 002, company: "MongoDB2" }
] )

$eq Coincidencia en una cadena

Las cadenas devuelven los mismos valores independientemente de si se utiliza una coincidencia implícita o un uso explícito de $eq. Las siguientes consultas devuelven el mismo resultado:

db.collection.find( { company: "MongoDB" }, {_id: 0 })
db.collection.find( { company: { $eq: "MongoDB" } }, {_id: 0 } )

El resultado es:

[ { company: "MongoDB" } ]

$eq Coincidencia en una expresión regular

Una consulta explícita que usa $eq y una expresión regular solo coincide con un objeto que también sea una expresión regular. La consulta de ejemplo no devuelve ningún resultado porque los valores del campo company son cadenas.

db.companies.find( { company: { $eq: /MongoDB/ } }, {_id: 0 } )

Coincidencias de expresiones regulares

Una consulta con una coincidencia implícita con una expresión regular es equivalente a una consulta que utiliza el operador $regex. Las siguientes consultas devuelven el mismo resultado:

db.companies.find( { company: /MongoDB/ }, {_id: 0 })
db.companies.find( { company: { $regex: /MongoDB/ } }, {_id: 0 } )

Los resultados son:

[
   { company: "MongoDB" },
   { company: "MongoDB2" }
]

Volver

Comparación

$gt