/ /

$toArray (operador de expresión)

Definición

$toArray

Convierte un valor en un arreglo. Si el valor no puede convertirse, se producen errores en $toArray. Si el valor es null o falta, $toArray devuelve null.

$toArray tiene la siguiente sintaxis:

{
   $toArray: <expression>
}

$toArray takes any valid expresión.

$toArray es una abreviatura para la siguiente $convert expresión:

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

Comportamiento

Expectativas del Tipo de input

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

Tipo de entrada	Comportamiento
binData	Devuelve un arreglo de valores numéricos. El tipo numérico de los elementos del arreglo depende del formato binData.
String	Devuelve un arreglo correspondiente al contenido dentro del string. La string debe contener caracteres que representen un JSON válido.
Nulo o Faltante	Devuelve nulo.

Reglas de análisis

Al convertir un string en un arreglo, $toArray:

Se requiere una sintaxis JSON válida. No se permiten comentarios ni comas al final.
Requiere que el valor de nivel superior sea un arreglo. Si la string no representa un arreglo, $toArray errores.
No interpreta contenedores de tipo Extended JSON, como $oid, $date o Timestamp(...). Estos siguen siendo cadenas u objetos anidados en el resultado.

Conversión de BinData

Al convertir binData a un arreglo, $toArray:

Acepta binData con valores de subtipo 9.
Convierte los vectores PACKED_BIT en arreglos boolean.
Convierte los vectores INT8 en arreglos integer.
Convierte los vectores FLOAT32 en arreglos double.

Mapeo de tipos numéricos

$toArray convierte tipos numéricos según su valor y formato:

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

Ejemplos

La siguiente tabla muestra ejemplos de cómo utilizar $toArray para convertir cadenas en arreglos:

Ejemplo	Resultados
`$toArray: "[1, 2, 3]"`	[ 1, 2, 3 ]
`$toArray: '["a", "b", "c"]'`	[ 'a', 'b', 'c' ]
`$toArray: "[]"`	[ ]
`$toArray: "{}"`	Error: Input no coincide con el tipo esperado 'arreglo'
`$toArray: 123`	Error: Conversión no compatible de int a arreglo en $convert sin un valor onError
`$toArray: "123"`	Error: el input no representa un JSON válido: valor autónomo inesperado
`$toArray: "[{\"$oid\": \"507f1f77bcf86cd799439011\"}]"`	[ { '$oid': '507f1f77bcf86cd799439011' } ]
`$toArray: null`	Nulo

Convertir string a arreglo

Inserte un documento en la colección jsonStrings:

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

La siguiente operación convierte cadenas a arreglos:

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

El campo numbers en el resultado es un arreglo de enteros, y documents es un arreglo de documentos incrustados:

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

Convertir BinData en arreglo

La siguiente operación convierte los vectores de binData en arreglos:

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