/ /

$toArray (operador de expresión)

Definición

$toArray

Convierte un valor en una matriz. Si el valor no se puede convertir, se produce un error ( $toArray). Si el valor es null o no está presente, se devuelve null ( $toArray).

$toArray tiene la siguiente sintaxis:

{
   $toArray: <expression>
}

$toArray takes any valid expresión.

$toArray es una forma abreviada de la siguiente expresión:$convert

{ $convert: { input: <expression>, to: "array" } }

Comportamiento

Expectativas sobre el tipo de entrada

La siguiente tabla describe el comportamiento de $toArray para diferentes tipos de entrada:

Tipo de entrada	Comportamiento
binData	Devuelve una matriz de valores numéricos. El tipo numérico de los elementos de la matriz depende del formato binData.
String	Devuelve una matriz que corresponde al contenido de la cadena. La cadena debe contener caracteres que representen una matriz JSON válida.
Nulo o faltante	Devuelve nulo.

Reglas de análisis sintáctico

Al convertir una cadena en una matriz, $toArray:

Requiere sintaxis JSON válida. No se permiten comentarios ni comas al final.
Requiere que el valor de nivel superior sea una matriz. Si la cadena no representa una matriz, se produce un error $toArray.
No interpreta los envoltorios de tipo JSON extendido como $oid, $date o Timestamp(...). Estos permanecen como cadenas u objetos anidados en el resultado.

Conversión de datos binarios

Al convertir binData a una matriz, $toArray:

Acepta datos binarios con valores de subtipo 9.
Convierte vectores PACKED_BIT en matrices boolean.
Convierte vectores INT8 en matrices integer.
Convierte vectores FLOAT32 en matrices double.

Mapeo de tipos numéricos

$toArray Convierte tipos numéricos en función de su valor y formato:

Los enteros dentro del rango con signo de 32bits se convierten en int.
Los enteros que están fuera del rango de bits 32pero dentro del rango con signo de bits 64se convierten en long.
Los enteros fuera del rango con signo de 64bits se convierten en double, lo que puede resultar en una pérdida de precisión.
Los números con punto decimal o notación exponencial se convierten en double.

Ejemplos

La siguiente tabla muestra ejemplos del uso de $toArray para convertir cadenas en matrices:

Ejemplo	Resultados
`$toArray: "[1, 2, 3]"`	[ 1, 2, 3 ]
`$toArray: '["a", "b", "c"]'`	[ 'a', 'b', 'c' ]
`$toArray: "[]"`	[ ]
`$toArray: "{}"`	Error: La entrada no coincide con el tipo esperado 'array'.
`$toArray: 123`	Error: Conversión no compatible de entero a matriz en $convert sin valor onError Nota La entrada debe ser una "cadena".
`$toArray: "123"`	Error: La entrada no representa un JSON válido: Valor independiente inesperado
`$toArray: "[{\"$oid\": \"507f1f77bcf86cd799439011\"}]"`	[ { '$oid': '507f1f77bcf86cd799439011' } ] Nota El formato JSON extendido no se reconoce.
`$toArray: null`	Nulo

Convertir cadena de texto a matriz

Inserte un documento en la colección jsonStrings:

db.jsonStrings.insertOne({_id: 1})

La siguiente operación convierte cadenas de texto en matrices:

db.jsonStrings.aggregate([
  {
    $project: {
      _id: 0,
      numbers: { $toArray: "[1, 2, 3]" },
      documents: { $toArray: '[{"a": 1}, {"b": 2}]' }
    }
  }
])

El campo numbers en el resultado es una matriz de enteros, y documents es una matriz de documentos incrustados:

{
  numbers: [ 1, 2, 3 ],
  documents: [ { a: 1 }, { b: 2 } ]
}

Convertir binData a matriz

La siguiente operación convierte vectores binData en matrices:

db.t.insertMany([
  // Empty PACKED_BIT vector converts to empty array
  { v: BinData(9, "EAA=") },
  // PACKED_BIT vector converts to bool array
  { v: BinData(9, "EAB/Bw==") },
  // INT8 vector converts to int array
  { v: BinData(9, "AwAAAQ==") },
  // FLOAT32 vector converts to double array
  { v: BinData(9, "JwCamZk+") },
  // FLOAT32 vector with special values converts to [-Infinity, 0, Infinity]
  { v: BinData(9, "JwAAAID/AAAAAAAAgH8=") }
])

db.t.aggregate([
  {
    $project: {
      _id: 0,
      original: "$v",
      asArray: { $toArray: "$v" }
    }
  }
])

La operación arroja:

[
  { original: Binary.fromPackedBits(new Uint8Array([])), asArray: [] },
  {
    original: Binary.fromPackedBits(new Uint8Array([ 127, 7 ])),
    asArray: [
      false, true,  true,  true,
      true,  true,  true,  true,
      false, false, false, false,
      false, true,  true,  true
    ]
  },
  {
    original: Binary.fromInt8Array(new Int8Array([ 0, 1 ])),
    asArray: [ 0, 1 ]
  },
  {
    original: Binary.fromFloat32Array(new Float32Array([ 0.30000001192092896 ])),
    asArray: [ 0.30000001192092896 ]
  },
  {
    original: Binary.fromFloat32Array(new Float32Array([ -Infinity, 0, Infinity ])),
    asArray: [ -Infinity, 0, Infinity ]
  }
]

Nota

Si la operación de conversión encuentra un error, la operación de agregación se detiene y genera un error. Para anular este comportamiento, use $convert en su lugar.

Volver

$tanh

$toBool