/ /

$filter (operador de expresió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>,
         arrayIndexAs: <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`.
`arrayIndexAs`	opcional. Un nombre para la variable de agregación que representa el índice del elemento actual en el arreglo `input`. El índice del primer elemento del arreglo es `0`. Puede usar el nombre de la variable en una expresión. Por ejemplo, si se especifica `arrayIndexAs: "myIndex"`, se usa `$$myIndex` en la expresión. `$$myIndex` devuelve el índice del elemento actual en el arreglo `input`. Si omites `arrayIndexAs`, puedes utilizar la variable del sistema `$$IDX` en la expresión para devolver el índice del elemento actual. Para ejemplos, consulta Accede al índice de cada elemento en un arreglo y Utiliza `$$IDX` para acceder al índice. Nuevo en la versión 8.3.
`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' } ]
   }
]

Accede al índice de cada elemento de un arreglo

Crea una colección de muestra llamada people con estos document:

db.people.insertMany( [
   { _id: 1, name: "Melissa", hobbies: [ "softball", "drawing", "reading" ] },
   { _id: 2, name: "Brad", hobbies: [ "gaming", "skateboarding" ] },
   { _id: 3, name: "Scott", hobbies: [ "basketball", "music", "fishing" ] },
   { _id: 4, name: "Tracey", hobbies: [ "acting", "yoga" ] },
   { _id: 5, name: "Josh", hobbies: [ "programming" ] },
   { _id: 6, name: "Claire" }
] )

El campo hobbies contiene un arreglo con los pasatiempos de cada persona en orden de clasificación. El primer hobby en el arreglo es el hobby principal de la persona al que le dedica más tiempo. El primer pasatiempo tiene un índice de arreglo de 0.

El siguiente ejemplo utiliza arrayIndexAs. La variable myIndex tiene el índice de cada hobby en el arreglo hobbies. El ejemplo devuelve documentos con estos campos:

Nombre de la persona.
secondaryHobbies arreglo que incluye todos los otros pasatiempos.

db.people.aggregate( [
   {
      $project: {
         _id: 0,
         name: 1,
         secondaryHobbies: {
            $filter: {
               input: "$hobbies",
               arrayIndexAs: "myIndex",
               cond: { $eq: [ { $mod: [ "$$myIndex", 2 ] }, 0 ] }
            }
         }
      }
   }
] )

Salida:

[
   { "name" : "Melissa", "secondaryHobbies" : [ "softball", "reading" ] }
   { "name" : "Brad", "secondaryHobbies" : [ "gaming" ] }
   { "name" : "Scott", "secondaryHobbies" : [ "basketball", "fishing" ] }
   { "name" : "Tracey", "secondaryHobbies" : [ "acting" ] }
   { "name" : "Josh", "secondaryHobbies" : [ "programming" ] }
   { "name" : "Claire", "secondaryHobbies" : null }
]

Use `$$IDX` para acceder al índice

La $$IDX variable devuelve el índice del elemento actual en el arreglo input. Puede usar $$IDX si omite el campo arrayIndexAs de la expresión.

El siguiente ejemplo devuelve los mismos **documents** que el ejemplo de la sección **anterior** Acceder al **índice** de cada elemento de un **arreglo**, pero utiliza $$IDX en lugar de arrayIndexAs:

db.people.aggregate( [
   {
      $project: {
         _id: 0,
         name: 1,
         secondaryHobbies: {
            $filter: {
               input: "$hobbies",
               cond: { $eq: [ { $mod: [ "$$IDX", 2 ] }, 0 ] }
            }
         }
      }
   }
] )

Volver

$expMovingAvg

$floor

Definición

Compatibilidad

Sintaxis

Comportamiento

Ejemplos

Filtro basado en la comparación de números

Utiliza el campo límite

límite mayor que las coincidencias posibles

Filtro basado en la coincidencia exacta de String

Filtro según coincidencia de expresión regular

Accede al índice de cada elemento de un arreglo

Use $$IDX para acceder al índice

Use `$$IDX` para acceder al índice