Make the MongoDB docs better! We value your opinion. Share your feedback for a chance to win $100.
Click here >
Menu Docs
Página inicial do Docs
/ /
Expressões
Página inicial do Docs
/
Desenvolvimento
/
Linguagem de query
/
Expressões
Página inicial do Docs
/
Desenvolvimento
/
Linguagem de query
/
Expressões

$map (operador de expressão )

Definição

$map

Aplica uma expressão a cada item em uma array e retorna uma array com os resultados aplicados.

Compatibilidade

Você pode utilizar o $map para implantações hospedadas nos seguintes ambientes:

  • MongoDB Atlas: o serviço totalmente gerenciado para implantações do MongoDB na nuvem

  • MongoDB Enterprise: a versão autogerenciada e baseada em assinatura do MongoDB

  • MongoDB Community: uma versão com código disponível, de uso gratuito e autogerenciada do MongoDB

Sintaxe

A expressão $map tem a seguinte sintaxe:

{
   $map: {
      input: <expression>,
      as: <string>,
      arrayIndexAs: <string>,
      in: <expression>
   }
}
Campo
Especificação

input

Uma expressão que se torna uma array.

Se input resolver para null ou se referir a um campo ausente, $map retornará null.

Se input resolver para um valor que não seja da array e não seja nulo, o pipeline será executado.

as

Opcional. Um nome para a variável que representa cada elemento individual da array input. Se nenhum nome for especificado, o nome da variável padrão será this.

arrayIndexAs

Opcional. Um nome para a variável de agregação que representa o índice do elemento atual na input array. O primeiro índice do elemento da array 0 é.

Você pode utilizar o nome da variável em uma expressão. Por exemplo, se você especificar arrayIndexAs: "myIndex", usará $$myIndex na expressão. $$myIndex retorna o índice do elemento atual na array input.

Se você arrayIndexAs omitir, você poderá utilizar a variável de sistema na expressão para retornar o índice do elemento $$IDX atual.

Para obter exemplos, consulte Acessar o índice de cada item em uma array e Usar $$IDX para acessar o índice.

Novidades na versão 8.3.

in

Uma expressão aplicada a cada elemento da array input . A expressão referencia cada elemento individualmente com o nome da variável especificado em as.

Para mais informações sobre expressões, consulte Expressões.

Exemplos

Adicionar a cada elemento de uma array

Os exemplos nesta página usam dados do conjunto de dados de amostra sample_mflix. Para obter detalhes sobre como carregar esse conjunto de dados em sua implantação autogerenciada do MongoDB , consulte Carregar o conjunto de dados de amostra. Se você fez modificações nos bancos de dados de amostra, talvez seja necessário descartar e recriar os bancos de dados para executar os exemplos nesta página.

A seguinte operação de agregação usa $map com a expressão para $add adicionar 10 a cada elemento na 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 de array

A operação de agregação a seguir usa $map para cada elemento truncate na location.geo.coordinates array para seu inteiro:

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 ] }
]

Aplique operadores aritméticos a cada elemento de array

A seguinte operação de agregação utiliza o estágio para adicionar um $addFields novo genreScores campo. A operação usa $map para aplicar $multiply e a cada elemento $add da genres array, calculando uma pontuação com base na contagem de caracteres de cada nome 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 ]
  }
]

Acesse o índice de cada item em uma array

O campo genres na coleção movies contém uma array de nomes de gênero para cada filme.

O exemplo a seguir usa arrayIndexAs. A variável myIndex tem o índice de cada gênero na array genres. O exemplo retorna documentos com estes campos:

  • Título do filme.

  • Nome do gênero.

  • Posição do gênero na array genres no campo rank.

  • isPrimary booleano que é true para o primeiro gênero na array e false para os outros 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 }
    ]
  }
]

Use $$IDX para acessar o índice

A variável retorna o índice do elemento atual $$IDX na input array. Você pode usar $$IDX se omitir o arrayIndexAs campo da expressão.

O exemplo a seguir retorna os mesmos documentos que o exemplo anterior em Acessar o índice de cada item em uma array, mas usa $$IDX em vez 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 }
    ]
  }
]

Saiba mais

Para saber mais sobre as expressões usadas nos exemplos anteriores, consulte:

Voltar

$ltrim

Próximo

$maxN-array-element

Nesta página