/ /

$type (operador de expresión)

Definición

$type

Devuelve una cadena que especifica el Tipo BSON del argumento.

$type tiene la siguiente sintaxis de expresión de operador:

{ $type: <expression> }

El argumento puede ser cualquier expresiónválida.

Tip

$isNumber - comprueba si el argumento es un número.
$type (Query) - filtra campos según el tipo BSON.

Comportamiento

`$type`

A diferencia del operador del query $type, que empareja los elementos de la arreglo en función de su tipo BSON, el operador de agregación $type no examina los elementos de la arreglo. En cambio, cuando se pasa un arreglo como argumento, el operador de agregación $type devuelve el tipo del argumento, es decir, "array".

Si el argumento es un campo que falta en el documento de entrada, $type devuelve la cadena "missing".

La siguiente tabla muestra la salida para varios tipos comunes de $type expresiones:

Ejemplo	Resultados
`{ $type: "a" }`	`"string"`
`{ $type: /a/ }`	`"regex"`
`{ $type: 1 }`	`"double"`
`{ $type: Long(627) }`	`"long"`
`{ $type: { x: 1 } }`	`"object"`
`{ $type: [ [ 1, 2, 3 ] ] }`	`"array"`

Nota

En el caso de un arreglo literal como [ 1, 2, 3 ], encierre la expresión en un conjunto externo de corchetes de arreglo para evitar que MongoDB interprete [ 1, 2, 3 ] como una lista de argumentos con tres argumentos (1, 2, 3). Envolver el arreglo [ 1, 2, 3 ] en una expresión $literal logra el mismo resultado.

Consulta formas de sintaxis de expresiones de operador para obtener más información.

Tipos disponibles

Tipo	Número	Alias	notas
Double	1	"double"
String	2	"string"
Objeto	3	"objeto"
Arreglo	4	"arreglo"
Datos binarios	5	"binData"
Indefinido	6	"indefinido"	Obsoleto.
ObjectId	7	"objectId"
Booleano	8	"bool"
fecha	9	"date"
Nulo	10	"null"
Expresión regular	11	"regex"
DBPointer	12	"dbPointer"	Obsoleto.
JavaScript	13	"javascript"
Símbolo	14	"symbol"	Obsoleto.
JavaScript con ámbito	15	"javascriptConÁmbito"	Obsoleto.
entero de 32 bits	16	"int"
Marca de tiempo	17	"timestamp"
entero de 64 bits	18	"long"
Decimal128	19	"Decimal"
Min key	-1	"minKey"
Clave máxima	127	"maxKey"

Si el argumento es un campo que falta en el documento de entrada, $type devuelve la cadena "missing".

Ejemplo

Este ejemplo usa una colección llamada coll con los siguientes documentos:

db.coll.insertMany( [
   { _id: 0, a : 8 },
   { _id: 1, a : [ 41.63, 88.19 ] },
   { _id: 2, a : { a : "apple", b : "banana", c: "carrot" } },
   { _id: 3, a :  "caribou" },
   { _id: 4, a : Long(71) },
   { _id: 5, a : null },
   { _id: 6 }
] )

La siguiente operación de agregación utiliza el operador $type para mostrar el tipo de campo a de todos los documentos como parte de la etapa $project.

db.coll.aggregate([{
    $project: {
       a : { $type: "$a" }
    }
}])

[
   { _id: 0, "a" : "int" },
   { _id: 1, "a" : "array" },
   { _id: 2, "a" : "object" },
   { _id: 3, "a" : "string" },
   { _id: 4, "a" : "long" },
   { _id: 5, "a" : "null" },
   { _id: 6, "a" : "missing" }
]

Comprobación de existencia

Expresiones no admite el operador $exists. Para evaluar si un campo existe o no en una expresión, puede utilizar el tipo missing.

La siguiente operación de agregación utiliza el tipo missing para añadir un campo a a los documentos de la colección coll (mencionada anteriormente) que carecen del campo a. Observa que un documento donde a: null no es igual a un documento donde falta el campo a.

db.coll.aggregate([  
  {  
    $addFields: {  
      a: {  
        $cond: {  
          if: { $eq: [{ $type: "$a" }, "missing"] },
          then: [], 
          else: "$a"
        }  
      }  
    }  
  }  
])

[
   { _id: 0, a : 8 },
   { _id: 1, a : [ 41.63, 88.19 ] },
   { _id: 2, a : { a : "apple", b : "banana", c: "carrot" } },
   { _id: 3, a :  "caribou" },
   { _id: 4, a : Long(71) },
   { _id: 5, a : null },
   { _id: 6, a : [] }
]

Volver

$trunc

$unsetField