Docs Home → MongoDB Manual

$zip (aggregation)

On this page本页内容

Definition定义

$zip

Transposes an array of input arrays so that the first element of the output array would be an array containing, the first element of the first input array, the first element of the second input array, etc.转换输入数组的数组，使得输出数组的第一元素将是包含第一输入数组的第一元件、第二输入数组的第二元件等的数组。

For example, $zip would transform [ [ 1, 2, 3 ], [ "a", "b", "c" ] ] into [ [ 1, "a" ], [ 2, "b" ], [ 3, "c" ] ].例如，$zip会将[ [ 1, 2, 3 ], [ "a", "b", "c" ] ]转换为[ [ 1, "a" ], [ 2, "b" ], [ 3, "c" ] ]。

$zip has the following syntax:具有以下语法：

{
    $zip: {
        inputs: [ <array expression1>,  ... ],
        useLongestLength: <boolean>,
        defaults:  <array expression>
    }
}
Operand运算数Description描述
inputsAn array of expressions that resolve to arrays. 解析为数组的表达式数组。The elements of these input arrays combine to form the arrays of the output array.这些输入数组的元素组合起来形成输出数组的数组。
If any of the inputs arrays resolves to a value of null or refers to a missing field, $zip returns null.如果任何inputs数组解析为null值或引用了缺失的字段，$zip将返回null。
If any of the inputs arrays does not resolve to an array or null nor refers to a missing field, $zip returns an error. 如果任何inputs数组都没有解析为数组或null，也没有引用丢失的字段，$zip将返回一个错误。
useLongestLengthA boolean which specifies whether the length of the longest array determines the number of arrays in the output array.一个布尔值，指定最长数组的长度是否决定输出数组中的数组数。
The default value is false: the shortest array length determines the number of arrays in the output array. 默认值为false：最短的数组长度决定了输出数组中的数组数量。
defaultsAn array of default element values to use if the input arrays have different lengths. 如果输入数组的长度不同，则使用默认元素值的数组。You must specify useLongestLength: true along with this field, or else $zip will return an error.必须将useLongestLength:true与此字段一起指定，否则$zip将返回错误。
If useLongestLength: true but defaults is empty or not specified, $zip uses null as the default value.如果useLongestLength:true但defaults为空或未指定，$zip将使用null作为默认值。
If specifying a non-empty defaults, you must specify a default for each input array or else $zip will return an error. 如果指定非空defaults，则必须为每个输入数组指定一个默认值，否则$zip将返回错误。

Behavior行为

The input arrays do not need to be of the same length. 输入数组不需要具有相同的长度。By default, the output array has the length of the shortest input array, but the useLongestLength option instructs $zip to output an array as long as the longest input array.默认情况下，输出数组的长度为最短输入数组的长度，但useLongestLength选项指示$zip输出与最长输入数组一样长的数组。

Example示例Results结果
 
{ $zip: { inputs: [ [ "a" ], [ "b" ], [ "c" ] ] }
 
[ [ "a", "b", "c" ] ]
{ $zip: { inputs: [ [ "a" ], [ "b", "c" ] ] } }
 
[ [ "a", "b" ] ]
{
  $zip: {
     inputs: [ [ 1 ], [ 2, 3 ] ],
     useLongestLength: true
  }
}
 
[ [ 1, 2 ], [ null, 3 ] ]
{
  $zip: {
     inputs: [ [ 1 ], [ 2, 3 ], [ 4 ] ],
     useLongestLength: true,
     defaults: [ "a", "b", "c" ]
  }
}
Because useLongestLength: true, $zip will pad the shorter input arrays with the corresponding defaults elements.因为useLongestLength: true，$zip将用相应的defaults元素填充较短的输入数组。
This yields [ [ 1, 2, 4 ], [ "a", 3, "c" ] ]. 这产生了[ [ 1, 2, 4 ], [ "a", 3, "c" ] ]。

Example实例

Matrix Transposition矩阵换位

A collection called matrices contains the following documents:一个名为matrices的集合包含以下文档：

db.matrices.insertMany([
  { matrix: [[1, 2], [2, 3], [3, 4]] },
  { matrix: [[8, 7], [7, 6], [5, 4]] },
])

To compute the transpose of each 3x2 matrix in this collection, you can use the following aggregation operation:要计算此集合中每个3x2矩阵的转置，可以使用以下聚合操作：

db.matrices.aggregate([{
  $project: {
    _id: false,
    transposed: {
      $zip: {
        inputs: [
          { $arrayElemAt: [ "$matrix", 0 ] },
          { $arrayElemAt: [ "$matrix", 1 ] },
          { $arrayElemAt: [ "$matrix", 2 ] },
        ]
      }
    }
  }
}])

This will return the following 2x3 matrices:这将返回以下2x3矩阵：

{ "transposed" : [ [ 1, 2, 3 ], [ 2, 3, 4 ] ] }
{ "transposed" : [ [ 8, 7, 5 ], [ 7, 6, 4 ] ] }

Filtering and Preserving Indexes筛选和保存索引

You can use $zip with $filter to obtain a subset of elements in an array, saving the original index alongside each retained element.您可以使用$zip和$filter来获得数组中元素的子集，将原始索引与每个保留的元素一起保存。

A collection called pages contains the following document:一个名为pages的集合包含以下文档：

db.pages.insertOne( {
  "category": "unix",
  "pages": [
    { "title": "awk for beginners", reviews: 5 },
    { "title": "sed for newbies", reviews: 0 },
    { "title": "grep made simple", reviews: 2 },
] } )

The following aggregation pipeline will first zip the elements of the pages array together with their index, and then filter out only the pages with at least one review:以下聚合管道将首先将pages数组的元素及其索引压缩在一起，然后只筛选出至少有一个审阅的页面：

db.pages.aggregate([{
  $project: {
    _id: false,
    pages: {
      $filter: {
        input: {
          $zip: {
            inputs: [ "$pages", { $range: [0, { $size: "$pages" }] } ]
          }
        },
        as: "pageWithIndex",
        cond: {
          $let: {
            vars: {
              page: { $arrayElemAt: [ "$$pageWithIndex", 0 ] }
            },
            in: { $gte: [ "$$page.reviews", 1 ] }
          }
        }
      }
    }
  }
}])

This will return the following document:这将返回以下文档：

{
  "pages" : [
    [ { "title" : "awk for beginners", "reviews" : 5 }, 0 ],
    [ { "title" : "grep made simple", "reviews" : 2 }, 2 ] ]
}