$sortArray (aggregation)（聚合）

Sort by Document Fields按文档字段排序

If the array elements are documents, you can sort by a document field. Specify the field name and a sort direction, ascending (1), or descending (-1 ).如果数组元素是文档，则可以按文档字段排序。指定字段名和排序方向，升序（1）或降序（-1）。

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

Sort by Value按值排序

To sort the whole array by value, or to sort by array elements that are not documents, identify the input array and specify 1 for an ascending sort or -1 for descending sort in the sortBy parameter.要按值对整个数组进行排序，或按非文档的数组元素进行排序，请标识输入数组，并在sortBy参数中为升序指定1，为降序指定-1。

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

Considerations注意事项

• There is no implicit array traversal on the sort key.排序键上没有隐式数组遍历。
• Positional operators are not supported. A field name like "values.1" denotes a sub-field called "1" in the values array. It does not refer to the item at index 1 in the values array.不支持位置运算符。像“values.1”这样的字段名表示values数组中名为“1”的子字段。它不引用values数组中索引1处的项。
• When a whole array is sorted, the sort is lexicographic. The aggregation $sort stage, behaves differently. 当对整个数组进行排序时，排序是字典式的。聚合$sort阶段的行为不同。See $sort for more details.有关更多详细信息，请参阅$sort。
• When an array is sorted by a field, any documents or scalars that do not have the specified field are sorted equally. The resulting sort order is undefined.当数组按字段排序时，任何没有指定字段的文档或标量都会被同等排序。结果排序顺序未定义。
• null values and missing values sort equally.值和缺失值排序相等。

Sort Stability排序稳定性

The stability of the sort is not specified. Users should not rely on $sortArray to use a particular sorting algorithm.未指定排序的稳定性。用户不应依赖$sortArray来使用特定的排序算法。

Sort on a Field按字段排序

The following operation sorts on the name field within the team array:以下操作对team数组中的name字段进行排序：

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

The operation returns the following results:该操作返回以下结果：

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

Sort on a Subfield按子字段排序

The following operation uses dot notation to sort the array based on the address subfield:以下操作使用点符号根据address子字段对数组进行排序：

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

The sort direction is descending because the sortBy value is "-1".排序方向为降序，因为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' }
      }
  ]
}

Sort on Multiple Fields在多个字段上排序

The following operation specifies multiple index fields to do a compound sort within the $sortArray operation:以下操作指定了多个索引字段，以便在$sortArray操作中进行复合排序：

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

Example output:示例输出：

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

Sort an Array of Integers对整数数组进行排序

This example specifies an input array directly. The values are all the same type, Int32:此示例直接指定输入数组。这些值都是相同的类型，Int32：

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

Example output:示例输出：

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

The input array has a "1" in position 0 and position 2. The ones are grouped together in the results, but their are no guarantees regarding how the group of ones is sorted relative to their original order.输入数组在位置0和位置2有一个“1”。这些元素在结果中被组合在一起，但它们并不能保证这组元素相对于其原始顺序是如何排序的。

Sort on Mixed Type Fields按混合类型字段排序

This example specifies an input array directly. The values have different types:此示例直接指定输入数组。这些值有不同的类型：

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

Example output:示例输出：

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

The results are ordered.结果是有序的。

In contrast, after changing the sortBy field to sort on the one of the document fields, sortBy: { a: 1 }, the sort order for the scalar and null values is undefined:相比之下，在将sortBy字段更改为对其中一个文档字段sortBy:{a:1}进行排序后，标量和null值的排序顺序是未定义的：

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