Docs 菜单
Docs 主页
/
MongoDB Manual
/
参考
/
操作符
/
聚合管道操作符

$zip（聚合）

在此页面上

  • 定义
  • 行为
  • 例子

定义

$zip

版本 3.4 中的新增功能。

转置输入数组的数组，使输出数组的第一个元素将是一个数组，其中包含第一个输入数组的第一个元素、第二个输入数组的第一个元素等。

例如， $zip会将[ [ 1, 2, 3 ], [ "a", "b", "c" ] ]转换为[ [ 1, "a" ], [ 2, "b" ], [ 3, "c" ] ] 。

$zip 通过以下语法实现：

{
    $zip: {
        inputs: [ <array expression1>,  ... ],
        useLongestLength: <boolean>,
        defaults:  <array expression>
    }
}
操作数
说明
inputs

解析为大量的表达式的数组。 这些输入数组的元素组合起来形成输出数组的大量。

如果任何 inputs 数组解析为 null 的值或指向缺失的字段，$zip 将返回 null。

如果 inputs 数组中的任何一个没有解析为数组或 null，也没有指向缺失字段，$zip 会返回错误。

useLongestLength

一个布尔值，用于指定最长数组的长度是否决定输出数组中的数组数量。

默认值为 false：最短数组的长度决定输出数组中数组的数量。

defaults

如果输入数组具有不同长度，则使用默认元素值的数组。您必须在指定该字段的同时指定 useLongestLength: true，否则 $zip 将返回错误。

如果 useLongestLength: true 但是 defaults 为空或未指定，则 $zip 将使用 null 作为默认值。

如果指定非空 defaults，则必须为每个输入数组指定默认值，否则 $zip 将返回错误信息。

行为

输入数组不需要具有相同的长度。默认情况下，输出数组的长度为最短输入数组的长度，但 useLongestLength 选项会指示 $zip 输出与最长输入数组一样长的数组。

例子
结果
{ $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" ]
  }
}

因为 useLongestLength: true，$zip 将用相应的 defaults 元素填充较短的输入数组。

这将产生 [ [ 1, 2, 4 ], [ "a", 3, "c" ] ]。

例子

矩阵转置

名为 matrices 的集合包含以下文档：

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

要计算该集合中每个 3x2 矩阵的转置，您可以使用以下聚合操作：

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

这将返回以下 2x3 矩阵：

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

筛选和保留索引

您可以将 $zip 与 $filter 用于获取数组中元素的子集，将原始索引与每个保留的元素一起保存。

名为 pages 的集合包含以下文档：

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

以下聚合管道将首先压缩 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 ] }
          }
        }
      }
    }
  }
}])

这将返回以下文档：

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

后退

$year

来年

查询修饰符

在此页面上