/ /

$map (operador de expresión)

Definición

$map: Aplica una expresión a cada elemento de un arreglo y devuelve un arreglo con los resultados aplicados.

Compatibilidad

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

La expresión tiene la siguiente $map sintaxis:

{
   $map: {
      input: <expression>,
      as: <string>,
      arrayIndexAs: <string>,
      in: <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, `$map` 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 ver ejemplos, consulte Acceder al índice de cada elemento de una matriz y Usar `$$IDX` para acceder al índice. Nuevo en la versión 8.3.
`in`	Una expresión que se aplica a cada elemento del arreglo `input`. La expresión hace referencia a cada elemento individualmente con el nombre de variable especificado en `as`.

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

Ejemplos

Agregar a cada elemento de un arreglo

Los ejemplos de esta página utilizan datos del conjunto de datos de muestra sample_mflix. Para obtener más información sobre cómo cargar este conjunto de datos en la implementación autogestionada de MongoDB, consultar Cargar el conjunto de datos de muestra. Si se realizó alguna modificación en las bases de datos de muestra, es posible que se deban descartar y volver a crear las bases de datos para ejecutar los ejemplos de esta página.

La siguiente operación de agregación utiliza $map con la expresión $add para agregar 10 a cada elemento en el location.geo.coordinates array:

db.theaters.aggregate( [
   {
      $match: {
         theaterId: { $in: [ 1000, 1003, 1008 ] }
      }
   },
   {
      $project: {
         _id: 0,
         theaterId: 1,
         adjustedCoordinates: {
            $map: {
               input: "$location.geo.coordinates",
               as: "coord",
               in: { $add: [ "$$coord", 10 ] }
            }
         }
      }
   },
   { $sort: { theaterId: 1 } }
] )

[
  { theaterId: 1000, adjustedCoordinates: [ -83.24565, 54.85466 ] },
  { theaterId: 1003, adjustedCoordinates: [ -66.512016, 48.29697 ] },
  { theaterId: 1008, adjustedCoordinates: [ -111.96328, 48.367649 ] }
]

Truncar cada elemento del arreglo

La siguiente operación de agregación utiliza $map a cada elemento en el array truncate para convertirlo location.geo.coordinates a su entero:

db.theaters.aggregate( [
   {
      $match: {
         theaterId: { $in: [ 1000, 1003, 1008 ] }
      }
   },
   {
      $project: {
         _id: 0,
         theaterId: 1,
         integerCoordinates: {
            $map: {
               input: "$location.geo.coordinates",
               as: "coord",
               in: { $trunc: "$$coord" }
            }
         }
      }
   },
   { $sort: { theaterId: 1 } }
] )

[
  { theaterId: 1000, integerCoordinates: [ -93, 44 ] },
  { theaterId: 1003, integerCoordinates: [ -76, 38 ] },
  { theaterId: 1008, integerCoordinates: [ -121, 38 ] }
]

Aplicar operadores aritméticos a cada elemento del arreglo

La siguiente operación de agregación utiliza la etapa para agregar un $addFields nuevo genreScores campo. La operación utiliza $map para aplicar $multiply y a cada elemento en $add la genres matriz, calculando una puntuación basada en el recuento de caracteres de cada nombre de género:

db.movies.aggregate( [
  {
     $match: { runtime: { $gt: 1000 } }
  },
  {
     $addFields: {
        genreScores: {
           $map: {
              input: "$genres",
              as: "genre",
              in: {
                 $add: [
                    { $multiply: [ { $strLenCP: "$$genre" }, 2 ] },
                    1
                 ]
              }
           }
        }
     }
  },
  { $project: { _id: 0, title: 1, genres: 1, genreScores: 1 } },
  { $sort: { title: 1 } }
] )

[
  {
    genres: [ 'Documentary', 'History', 'Sport' ],
    title: 'Baseball',
    genreScores: [ 23, 15, 11 ]
  },
  {
    genres: [ 'Action', 'Adventure', 'Drama' ],
    title: 'Centennial',
    genreScores: [ 13, 19, 11 ]
  }
]

Accede al índice de cada elemento de un arreglo

El campo genres en la colección movies contiene un arreglo de nombres de géneros para cada película.

El siguiente ejemplo utiliza arrayIndexAs. La variable myIndex tiene el índice de cada género en el genres arreglo. El ejemplo devuelve documentos con estos campos:

Título de la película.
Nombre del género.
Posición del género en el arreglo genres en el campo rank.
isPrimary booleano que es true para el primer género del arreglo y false para los otros géneros.

db.movies.aggregate( [
   {
      $match: { runtime: { $gt: 1000 } }
   },
   {
      $project: {
         _id: 0,
         title: 1,
         rankedGenres: {
            $map: {
               input: "$genres",
               as: "genre",
               arrayIndexAs: "myIndex",
               in: {
                  genre: "$$genre",
                  rank: { $add: [ "$$myIndex", 1 ] },
                  isPrimary: { $eq: [ "$$myIndex", 0 ] }
               }
            }
         }
      }
   },
   { $sort: { title: 1 } }
] )

[
  {
    title: 'Baseball',
    rankedGenres: [
      { genre: 'Documentary', rank: 1, isPrimary: true },
      { genre: 'History', rank: 2, isPrimary: false },
      { genre: 'Sport', rank: 3, isPrimary: false }
    ]
  },
  {
    title: 'Centennial',
    rankedGenres: [
      { genre: 'Action', rank: 1, isPrimary: true },
      { genre: 'Adventure', rank: 2, isPrimary: false },
      { genre: 'Drama', rank: 3, isPrimary: false }
    ]
  }
]

Utilice `$$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 documentos que el ejemplo anterior en Acceder al índice de cada elemento de una matriz, pero utiliza $$IDX en lugar arrayIndexAs de:

db.movies.aggregate( [
   {
      $match: { runtime: { $gt: 1000 } }
   },
   {
      $project: {
         _id: 0,
         title: 1,
         rankedGenres: {
            $map: {
               input: "$genres",
               as: "genre",
               in: {
                  genre: "$$genre",
                  rank: { $add: [ "$$IDX", 1 ] },
                  isPrimary: { $eq: [ "$$IDX", 0 ] }
               }
            }
         }
      }
   },
   { $sort: { title: 1 } }
] )

[
  {
    title: 'Baseball',
    rankedGenres: [
      { genre: 'Documentary', rank: 1, isPrimary: true },
      { genre: 'History', rank: 2, isPrimary: false },
      { genre: 'Sport', rank: 3, isPrimary: false }
    ]
  },
  {
    title: 'Centennial',
    rankedGenres: [
      { genre: 'Action', rank: 1, isPrimary: true },
      { genre: 'Adventure', rank: 2, isPrimary: false },
      { genre: 'Drama', rank: 3, isPrimary: false }
    ]
  }
]

Obtén más información

Para aprender más sobre las expresiones utilizadas en los ejemplos anteriores, consulte:

Volver

$ltrim

$maxN-array-element