/ /

Expressões

Página inicial do Docs

/ /

Linguagem de query

Expressões

Página inicial do Docs

$type (agregação)

Definição

$type

Retorna uma string que especifica o tipo BSON do argumento.

$type tem a seguinte sintaxe de expressão do operador:

{ $type: <expression> }

O argumento pode ser qualquer expressãoválida.

Dica

$isNumber - verifica se o argumento é um número.
$type (Query) - filtra campos com base no tipo BSON.

Comportamento

`$type`

Ao contrário do operador de query $type, que corresponde a elementos de array com base em seu tipo BSON, o operador de agregação $type não examina elementos de array. Em vez disso, quando uma array é passada como seu argumento, o operador de agregação $type retorna o tipo do argumento, ou seja, "array".

Se o argumento for um campo ausente no documento de entrada, $type retornará a string "missing".

A tabela a seguir mostra a saída $type para vários tipos comuns de expressões:

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

Observação

No caso de uma array literal, como [ 1, 2, 3 ], coloque a expressão em um conjunto externo de colchetes para evitar que o MongoDB analise [ 1, 2, 3 ] como uma lista de argumentos com três argumentos (1, 2, 3). Agrupar a array [ 1, 2, 3 ] em uma expressão $literal obtém o mesmo resultado.

Consulte Formulários de sintaxe de expressão do operador para mais informações.

Tipos disponíveis

Tipo	Número	Alias	Notas
Double	1	"double"
String	2	"string"
Objeto	3	"objeto"
Array	4	"array"
Dados binários	5	"binData"
Indefinido	6	" indefinido "	Obsoleto.
ObjectId	7	"objectId"
Boolean	8	"bool"
Data	9	"data"
Zero	10	"nulo"
Expressão regular	11	"regex"
DBPointer	12	"dbPointer"	Obsoleto.
JavaScript	13	"javascript"
Símbolo	14	"símbolo"	Obsoleto.
JavaScript com escopo	15	"javascriptWithScope"	Obsoleto.
Inteiro de bits	16	"int"
Timestamp	17	" carimbo de data/hora "
Inteiro de 64 bits	18	"long"
Decimal128	19	"decimal"
Min key	-1	"minKey"
Tecla máxima	127	"maxKey"

Se o argumento for um campo ausente no documento de entrada, $type retornará a string "missing".

Exemplo

Este exemplo utiliza uma coleção denominada coll com os seguintes 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 }
] )

A seguinte operação de agregação utiliza o operador $type para exibir o tipo de campo a para todos os documentos como parte do estágio $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" }
]

Verificação de existência

As expressões não suportam o operador. Para avaliar se um campo existe ou não em uma expressão, você pode utilizar $exists o missing tipo.

A seguinte operação de agregação utiliza o tipo missing para adicionar um campo a a documentos da coleção coll acima que não possuem o campo a. Observe que um documento em que a: null não é o mesmo que um documento em que o campo a está ausente.

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

Voltar

$trunc

$unsetField