Página inicial do Docs → Desenvolver aplicações → Manual do MongoDB

$sortArray (agregação)

Nesta página

Definição

Comportamento
Exemplos

Definição

$sortArray

Novidades na versão 5,2.

Classifica uma array com base em seus elementos. A ordem de classificação é especificada pelo usuário.

$sortArray tem a seguinte sintaxe:

$sortArray: {
   input: <array>,
   sortBy: <sort spec>
}

Campo	Tipo	Descrição
`input`	expressão	A array a ser ordenada. O resultado é `null`, se a expressão: estiver ausente avaliar como `null` avaliar como `undefined` Se a expressão avaliar como qualquer outro valor que não array, o documento retornará um erro.
`sortBy`	documento	O documento especifica uma ordem de classificação.

Comportamento

A expressão $sortArray ordena a array input de acordo com a especificação sortBy .

A sintaxe e semântica $sortArray são as mesmas que o comportamento em uma operação $push modificada por $sort.

Classificar por campos de documento

Se os elementos de array forem documentos, você poderá ordenar por um campo de documento. Especifique o nome do campo e uma direção de ordenação, crescente (1) ou decrescente (-1).

{
   input: <array-of-documents>,
   sortBy: { <document-field>: <sort-direction> }
}

Ordenar por valor

Para classificar toda a array por valor ou por elementos de array que não sejam documentos, identifique a array de entrada e especifique 1 para uma ordem crescente ou -1 para uma ordem decrescente no parâmetro sortBy.

{
   input: <array-of-documents>,
   sortBy: <sort-direction>
}

Considerações

Não há traversal implícita de array na chave de ordenação.
Operadores posicionais não são suportados. Um nome de campo como "valores.1" denota um campo chamado "1" na array values. Não se refere ao item no índice 1 na array values.
Quando uma array inteira é ordenada, a ordem é lexicográfica. O estágio de aggregation $sort se comporta de forma diferente. Consulte $sort para obter mais detalhes.
Quando uma array é classificada por um campo, todos os documentos ou escalares que não têm o campo especificado são classificados igualmente. A ordem de classificação resultante é indefinida.
null valores existentes e valores ausentes são ordenados igualmente.

Estabilidade da ordenação

A estabilidade da ordenação não é especificada. Os usuários não devem confiar em $sortArray para usar um algoritmo de ordenação específico.

Exemplos

Os exemplos do $sortArray nesta seção funcionam no MongoDB 5.2 e posterior.

Crie a coleção team:

db.engineers.insertOne(
   {
      "team":
         [
            {
              "name": "pat",
              "age": 30,
              "address": { "street": "12 Baker St", "city": "London" }
            },
            {
              "name": "dallas",
              "age": 36,
              "address": { "street": "12 Cowper St", "city": "Palo Alto" }
            },
            {
              "name": "charlie",
              "age": 42,
              "address": { "street": "12 French St", "city": "New Brunswick" }
            }
         ]
   }
)

A array team tem três elementos. Cada elemento de team tem subelementos agrupados: name, age e address. Os exemplos seguintes mostram como ordenar a array team utilizando estes subelementos.

Ordenar em um campo

Ordenar em um campo dentro de um elemento de array:

db.engineers.aggregate( [
   { $project:
      {
          _id: 0,
          result:
            {
               $sortArray: { input: "$team", sortBy: { name: 1 } }
            }
      }
   }
] )

O campo name é um subelemento na array team. A operação retorna os seguintes resultados:

{
   result:
   [
      {
        name: 'charlie',
        age: 42,
        address: { street: '12 French St', city: 'New Brunswick' }
      },
      {
        name: 'dallas',
        age: 36,
        address: { street: '12 Cowper St', city: 'Palo Alto' }
      },
      {
        name: 'pat',
        age: 30,
        address: { street: '12 Baker St', city: 'London' }
      }
   ]
}

Ordenar em um subcampo

O campo address é um documento com subcampos próprios. Use a notação de ponto para ordenar a array com base em um subcampo:

db.engineers.aggregate( [
   {
      $project:
         {
                _id: 0,
                result:
               {
                  $sortArray:
                     {
                        input: "$team",
                        sortBy: { "address.city": -1 }
                     }
               }
             }
   }
] )

A direção de ordenação é decrescente porque o valor sortBy é "-1".

{
  result: [
    {
      name: 'dallas',
      age: 36,
      address: { street: '12 Cowper St', city: 'Palo Alto' }
    },
    {
      name: 'charlie',
      age: 42,
      address: { street: '12 French St', city: 'New Brunswick' }
    },
    {
      name: 'pat',
      age: 30,
      address: { street: '12 Baker St', city: 'London' }
    }
  ]
}

Classificar em Vários Campos

Especifique vários campos de índice para fazer uma ordenação composta:

db.engineers.aggregate( [
   {
      $project:
         {
            _id: 0,
            result:
               {
                  $sortArray:
                     {
                        input: "$team",
                        sortBy: { age: -1, name: 1 }
                     }
               }
         }
    }
 ] )

Saída de exemplo:

{
  name: 'charlie',
  age: 42,
  address: { street: '12 French St', city: 'New Brunswick' }
},
{
  name: 'dallas',
  age: 36,
  address: { street: '12 Cowper St', city: 'Palo Alto' }
},
{
  name: 'pat',
  age: 30,
  address: { street: '12 Baker St', city: 'London' }
}

Ordenar uma array de números inteiros

Este exemplo especifica uma array de entrada diretamente. Os valores são todos do mesmo tipo, Int32:

db.engineers.aggregate( [
   {
      $project:
         {
            _id: 0,
            result:
               {
                  $sortArray:
                     {
                         input: [ 1, 4, 1, 6, 12, 5 ],
                         sortBy: 1
                     }
               }
         }
   }
] )

Saída de exemplo:

[ { result: [ 1, 1, 4, 5, 6, 12 ] } ]

A array de entrada tem um "1" na posição 0 e na posição 2. Os números "1" são agrupados nos resultados, mas não há garantias sobre como o grupo de "1" é ordenado em relação à sua ordem original.

Classificar em campos de tipo misto

Este exemplo especifica uma array de entrada diretamente. Os valores têm tipos diferentes:

db.engineers.aggregate( [
   {
      $project:
         {
            _id: 0,
            result:
            {
               $sortArray:
                  {
                     input: [ 20, 4, { a: "Free" }, 6, 21, 5, "Gratis",
                             { a: null }, { a: { sale: true, price: 19 } },
                             Decimal128( "10.23" ), { a: "On sale" } ],
                     sortBy: 1
                  }
            }
         }
   }
] )

Saída de exemplo:

{ result: [
      4,
      5,
      6,
      Decimal128("10.23"),
      20,
      21,
      'Gratis',
      { a: null },
      { a: 'Free' },
      { a: 'On sale' },
      { a: { sale: true, price: 19 } }
] }

Os resultados são ordenados.

Por outro lado, depois de alterar o campo sortBy para ordenar o "1" dos campos de documento, sortBy: { a: 1 }, a ordem de classificação para os valores escalares e null é indefinida:

{ result: [
     20,
     4,
     6,
     21,
     5,
     'Gratis',
     { a: null },
     Decimal128("10.23"),
     { a: 'Free' },
     { a: 'On sale' },
     { a: { sale: true, price: 19 } }
] }

← $slice (agregação)

$split (agregação) →