/ /

$filter (operador de agregación)

Definición

$filter: Selecciona un subconjunto de un arreglo para devolverlo según la condición especificada. Devuelve un arreglo con solo aquellos elementos que cumplen con la condición. Los elementos devueltos están en el orden original.

Compatibilidad

Puedes usar $filter 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

$filter tiene la siguiente sintaxis:

{
    $filter:
      {
         input: <array>,
         as: <string>,
         cond: <expression>,
         limit: <number expression>
      }
}

Campo	Especificación
`input`	Una expresión que se evalúa en un arreglo. Si `input` se resuelve en `null` o hace referencia a un campo que falta, `$filter` devuelve `null`. Si `input` se resuelve en un valor que no es un arreglo ni nulo, el pipeline presenta errores.
`as`	Opcional. Un nombre para la variable que representa cada elemento individual del arreglo `input`. Si no se especifica un nombre, el nombre de la variable por defecto es `this`.
`cond`	Una expresión que se resuelve en un valor booleano utilizado para determinar si un elemento debe incluirse en el arreglo de salida. La expresión hace referencia a cada elemento del arreglo `input` individualmente con el nombre de variable especificado en `as`.
`limit`	Opcional. Una expresión numérica que limita la cantidad de elementos coincidentes del arreglo que `$filter` devuelve. No se puede especificar un límite inferior a `1`. Los elementos coincidentes del arreglo se devuelven en el orden en que aparecen en el arreglo de entrada. Si el `limit` especificado es mayor que el número de elementos coincidentes del arreglo, `$filter` devuelve todos los elementos coincidentes del arreglo. Si el límite es `null`, `$filter` devuelve todos los elementos del arreglo que coinciden.

Para obtener más información sobre las expresiones, consulta Expresiones.

Comportamiento

Ejemplo

Resultados

{
  $filter: {
     input: [ 1, "a", 2, null, 3.1, Long(4), "5" ],
     as: "num",
     cond: { $isNumber: "$$num" }
  }
}

[ 1, 2, 3.1, Long(4) ]

{
  $filter: {
     input: [ 1, "a", 2, null, 3.1, Long(4), "5" ],
     as: "num",
     cond: { $isNumber: "$$num" },
     limit: 2
  }
}

[ 1, 2 ]

{
  $filter: {
     input: [ 1, "a", 2, null, 3.1, Long(4), "5" ],
     as: "num",
     cond: { $isNumber: "$$num" },
     limit: { $add: [ 0, 1 ] }
  }
}

[ 1 ]

Ejemplos

Una colección sales tiene los siguientes documentos:

db.sales.insertMany( [
   {
      _id: 0,
      items: [
         { item_id: 43, quantity: 2, price: 10, name: "pen" },
         { item_id: 2, quantity: 1, price: 240, name: "briefcase" }
      ]
   },
   {
      _id: 1,
      items: [
         { item_id: 23, quantity: 3, price: 110, name: "notebook" },
         { item_id: 103, quantity: 4, price: 5, name: "pen" },
         { item_id: 38, quantity: 1, price: 300, name: "printer" }
      ]
   },
   {
      _id: 2,
      items: [
         { item_id: 4, quantity: 1, price: 23, name: "paper" }
      ]
   }
] )

Filtro basado en la comparación de números

El siguiente ejemplo filtra el arreglo items para incluir solo documentos que tengan un price mayor o igual a 100:

db.sales.aggregate( [
   {
      $project: {
         items: {
            $filter: {
               input: "$items",
               as: "item",
               cond: { $gte: [ "$$item.price", 100 ] }
            }
         }
      }
   }
] )

[
   {
      _id: 0,
      items: [ { item_id: 2, quantity: 1, price: 240, name: 'briefcase' } ]
   },
   {
      _id: 1,
      items: [
         { item_id: 23, quantity: 3, price: 110, name: 'notebook' },
         { item_id: 38, quantity: 1, price: 300, name: 'printer' }
      ]
   },
   { _id: 2, items: [] }
]

Utiliza el campo límite

Este ejemplo utiliza la colección sales del ejemplo anterior.

El ejemplo utiliza el campo limit para especificar el número de elementos coincidentes devueltos en cada arreglo items.

db.sales.aggregate( [
   {
      $project: {
         items: {
            $filter: {
               input: "$items",
               as: "item",
               cond: { $gte: [ "$$item.price", 100 ] },
               limit: 1
            }
         }
      }
   }
] )

[
   {
      _id: 0,
      items: [ { item_id: 2, quantity: 1, price: 240, name: 'briefcase' } ]
   },
   {
      _id: 1,
      items: [ { item_id: 23, quantity: 3, price: 110, name: 'notebook' } ]
   },
   { _id: 2, items: [] }
]

límite mayor que las coincidencias posibles

Este ejemplo utiliza la colección sales del ejemplo anterior.

El ejemplo utiliza un valor de campo limit que es mayor que el número posible de elementos coincidentes que se pueden devolver. En este caso, limit no afecta los resultados de la query y devuelve todos los documentos que coinciden con los criterios de filtro $gte.

db.sales.aggregate( [
   {
      $project: {
         items: {
            $filter: {
               input: "$items",
               as: "item",
               cond: { $gte: [ "$$item.price", 100] },
               limit: 5
            }
         }
      }
   }
] )

[
   {
      _id: 0,
      items: [ { item_id: 2, quantity: 1, price: 240, name: 'briefcase' } ]
   },
   {
      _id: 1,
      items: [
         { item_id: 23, quantity: 3, price: 110, name: 'notebook' },
         { item_id: 38, quantity: 1, price: 300, name: 'printer' }
      ]
   },
   { _id: 2, items: [] }
]

Filtro basado en la coincidencia exacta de String

Este ejemplo utiliza la colección sales del ejemplo anterior.

Los siguientes filtros de agregación para items que tienen un valor de name de pen.

db.sales.aggregate( [
   {
      $project: {
         items: {
            $filter: {
               input: "$items",
               as: "item",
               cond: { $eq: [ "$$item.name", "pen"] }
            }
         }
      }
   }
] )

[
   {
      _id: 0,
      items: [ { item_id: 43, quantity: 2, price: 10, name: 'pen' } ]
   },
   {
      _id: 1,
      items: [ { item_id: 103, quantity: 4, price: 5, name: 'pen' } ]
   },
   { _id: 2, items: [] }
]

Filtro según coincidencia de expresión regular

Este ejemplo utiliza la colección sales del ejemplo anterior.

La siguiente agregación utiliza $regexMatch para filtrar por items que tienen un valor de name que empieza con p:

db.sales.aggregate( [
   {
      $project: {
         items: {
            $filter: {
               input: "$items",
               as: "item",
               cond: {
                  $regexMatch: { input: "$$item.name", regex: /^p/ }
               }
            }
         }
      }
   }
] )

[
   {
      _id: 0,
      items: [ { item_id: 43, quantity: 2, price: 10, name: 'pen' } ]
   },
   {
      _id: 1,
      items: [
         { item_id: 103, quantity: 4, price: 5, name: 'pen' },
         { item_id: 38, quantity: 1, price: 300, name: 'printer' }
      ]
   },
   {
      _id: 2,
      items: [ { item_id: 4, quantity: 1, price: 23, name: 'paper' } ]
   }
]

Volver

$expMovingAvg

$floor