$zip (agregación)

Definición

$zip

Transpone un arreglo de arreglos de entrada de modo que el primer elemento del arreglo de salida sea un arreglo que contenga, el primer elemento del primer arreglo de entrada, el primer elemento del segundo arreglo de entrada, etc.

Por ejemplo, $zip transformaría [ [ 1, 2, 3 ], [ "a", "b", "c" ] ] en [ [ 1, "a" ], [ 2, "b" ], [ 3, "c" ] ].

$zip tiene la siguiente sintaxis:

{
    $zip: {
        inputs: [ <array expression1>,  ... ],
        useLongestLength: <boolean>,
        defaults:  <array expression>
    }
}

Operando	Descripción
inputs	Un arreglo de las expresiones que se resuelven en arreglos. Los elementos de estos arreglos de entrada se combinan para formar los arreglos del arreglo de salida. Si cualquiera de los arreglos inputs resuelve un valor de null o se refiere a un campo que falta, $zip devuelve null. Si cualquiera de los arrays inputs no se resuelve en un array ni null ni hace referencia a un campo faltante, $zip devolverá un error.
useLongestLength	Un booleano que especifica si la longitud del arreglo más largo determina el número de arreglos en el arreglo de salida. El valor por defecto es false: la longitud más corta del arreglo determina el número de arreglos en el arreglo de salida.
defaults	Un arreglo de valores de elementos por defecto a utilizar si los arreglos de entrada tienen diferentes longitudes. Debe especificar useLongestLength: true junto con este campo, o de lo contrario $zip devolverá un error. Si useLongestLength: true, pero defaults está vacío o no está especificado, $zip utiliza null como valor por defecto. Si especifica un defaults no vacío, debe especificar un valor por defecto para cada arreglo de entrada o bien $zip devolverá un error.

Comportamiento

Las matrices de entrada no necesitan tener la misma longitud. De forma predeterminada, la matriz de salida tiene la longitud de la matriz de entrada más corta, pero la useLongestLength opción indica a que genere una matriz con la $zip misma longitud que la matriz de entrada más larga.

{ $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" ]
  }
}

Ejemplo

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

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

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

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

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