/ /

$sortArray (operador de expresión)

Definición

$sortArray

Nuevo en la versión 5.2.

Ordena un arreglo en función de sus elementos. El orden de clasificación lo especifica el usuario.

$sortArray tiene la siguiente sintaxis:

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

Campo	Tipo	Descripción
`input`	expresión	El arreglo a ordenar. El resultado es `null` si la expresión: Se evalúa como missing (faltante). Se evalúa en `null`. Se evalúa en `undefined`. Si la expresión se evalúa a cualquier otro valor que no sea un arreglo, la operación resultará en un error.
`sortBy`	documento o int (`1` o `-1`)	Un valor que especifica un orden de clasificación. Sus valores posibles son `1`, `-1` o un documento. Si el valor de `sortBy` es un documento, el orden de clasificación se refiere a pares de campo-dirección que determinan cómo ordenar los elementos del arreglo, como `{ name: 1, age: -1 }`, donde `1` indica orden ascendente y `-1` indica orden descendente. Si el valor de `sortBy` es `1`, MongoDB ordena el arreglo en orden ascendente. Si el valor de `sortBy` es `-1`, MongoDB ordena el arreglo de forma descendente.

Comportamiento

La expresión $sortArray ordena el arreglo input de acuerdo con la especificación sortBy.

La sintaxis y la semántica de $sortArray son las mismas que el comportamiento en un $push operación modificada por $sort.

Ordenar por campos de documento

Si los elementos del arreglo son documentos, puedes ordenar por un campo del documento. Especifica el nombre del campo y la dirección de ordenación, ascendente (1) o descendente (-1 ).

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

Ordenar por Valor

Para ordenar todo el arreglo por valor, o para ordenar por elementos del arreglo que no son documentos, identifique el arreglo de entrada y especifique 1 para un orden ascendente o -1 para descendente en el parámetro sortBy.

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

Considerations

No existe un recorrido implícito del arreglo en la clave de ordenación.
Los operadores posicionales no son compatibles. Un nombre de campo como "valores.1" denota un subcampo denominado "1" en el arreglo values. No se refiere al elemento en el índice 1 del arreglo values.
Cuando se ordena un arreglo completo, el ordenamiento es lexicográfico. La etapa de agregación $sort, se comporta de manera diferente. Para más detalles, consulta $sort.
Cuando un arreglo se ordena por un campo, cualquier documento o escalar que no contenga el campo especificado se ordena por igual. El orden resultante de clasificación no está definido.
null Los valores y los valores ausentes se ordenan de igual manera.

Estabilidad de la clasificación

No se especifica la estabilidad del tipo de ordenamiento. Los usuarios no deben depender de $sortArray para utilizar un algoritmo de ordenamiento en particular.

Ejemplos

Los ejemplos en esta sección usan un arreglo team en una colección engineers.

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

El team arreglo tiene tres elementos. Cada elemento de team tiene subelementos anidados: name, age y address. Los siguientes ejemplos muestran cómo ordenar el arreglo team usando estos subelementos.

Ordenar en un campo

La siguiente operación ordena en el campo name dentro del arreglo team:

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

La operación devuelve los siguientes 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 por un subcampo

La siguiente operación utiliza la notación de puntos para ordenar el arreglo según el subcampo address:

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

La dirección de clasificación es descendente porque el valor sortBy es "-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' }
      }
  ]
}

Ordenar en múltiples campos

La siguiente operación especifica varios campos de índice para realizar una clasificación compuesta dentro de la operación $sortArray:

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

Ejemplo de salida:

{
   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 un arreglo de enteros

Este ejemplo especifica un arreglo de entrada directamente. Los valores son todos del mismo tipo, Int32:

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

Ejemplo de salida:

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

El arreglo de entrada tiene un "1" en la posición 0 y en la posición 2. Los unos están agrupados juntos en los resultados, pero no hay garantías sobre cómo está ordenado el grupo de unos con respecto a su orden original.

Ordenar en campos de tipo mixto

Este ejemplo especifica un arreglo de entrada directamente. Los valores tienen 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
                  }
            }
         }
   }
] )

Ejemplo de salida:

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

Los resultados están ordenados.

En cambio, después de cambiar el campo sortBy para ordenar en uno de los campos del documento, sortBy: { a: 1 }, el orden de clasificación para los valores escalares y null no está definido:

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

Volver

$slice

$split