$type

Arrays数组

For documents where field is an array, $type returns documents in which at least one array element matches a type passed to $type.对于field为数组的文档，$type返回至少有一个数组元素与传递给$type的类型匹配的文档。

Queries for $type: "array" return documents where the field itself is an array.对$type: "array"的查询返回字段本身是数组的文档。

Available Types可用类型

The $type operator accepts string aliases for the BSON types in addition to the numbers corresponding to the BSON types. 除了与BSON类型对应的数字外，$type运算符还接受BSON类型的字符串别名。[1]

$type supports the number alias, which matches against the following BSON types:支持与以下BSON类型匹配的number别名：

• double
• 32-bit integer
• 64-bit integer
• decimal

For examples, see Examples.有关示例，请参阅示例。

MinKey and 和MaxKey

MinKey and 和MaxKey are used in comparison operations and exist primarily for internal use. 用于比较操作，主要用于内部使用。For all possible BSON element values, MinKey is always the smallest value while MaxKey is always the greatest value.对于所有可能的BSON元素值，MinKey始终是最小值，而MaxKey始终是最大值。

Querying for minKey or maxKey with $type only returns fields that match the special MinKey or MaxKey values.使用$type查询minKey或maxKey只会返回与特殊minKey或maxKey值匹配的字段。

Suppose that the data collection has two documents with MinKey and MaxKey:假设data集合有两个具有MinKey和MaxKey的文档：

db.data.insertMany( [
   { _id : 1, x : { "$minKey" : 1 } },
   { _id : 2, y : { "$maxKey" : 1 } }
] )

The following query returns the document with _id: 1:以下查询返回_id为1的文档：

db.data.find( { x: { $type: "minKey" } } )

The following query returns the document with _id: 2:以下查询返回_id为2的文档：

db.data.find( { y: { $type: "maxKey" } } )

Querying by Data Type按数据类型查询

The addressBook contains addresses and zipcodes, where zipCode has string, int, double, and long values:addressBook包含地址和邮政编码，其中zipCode有string、int、double和long值：

db.addressBook.insertMany( [
      { _id : 1, address : "2030 Martian Way", zipCode : "90698345" },
      { _id : 2, address : "156 Lunar Place", zipCode : 43339374 },
      { _id : 3, address : "2324 Pluto Place", zipCode : Long(3921412) },
      { _id : 4, address : "55 Saturn Ring" , zipCode : Int32(88602117) },
      { _id : 5, address : "104 Venus Drive", zipCode : ["834847278", "1893289032"] }
] )

The following queries return all documents where zipCode is the BSON type string or is an array containing an element of the specified type:以下查询返回所有zipCode为BSON类型string或包含指定类型元素的数组的文档：

db.addressBook.find( { zipCode : { $type : 2 } } );
db.addressBook.find( { zipCode : { $type : "string" } } );

These queries return:这些查询返回：

{ _id : 1, address : "2030 Martian Way", zipCode : "90698345" }
{ _id : 5, address : "104 Venus Drive", zipCode : [ "834847278", "1893289032" ] }

The following queries return all documents where zipCode is the BSON type double or is an array containing an element of the specified type:以下查询返回所有zipCode为BSON类型double或包含指定类型元素的数组的文档：

db.addressBook.find( { zipCode : { $type : 1 } } );
db.addressBook.find( { zipCode : { $type : "double" } } );

These queries return:这些查询返回：

{ _id : 2, address : "156 Lunar Place", zipCode : 43339374 }

The following query uses the number alias to return documents where zipCode is the BSON type double, int, or long or is an array containing an element of the specified types:以下查询使用number别名返回文档，其中zipCode是BSON类型double、int或long，或者是一个包含指定类型元素的数组：

db.addressBook.find( { zipCode : { $type : "number" } } )

These queries return:这些查询返回：

{ _id : 2, address : "156 Lunar Place", zipCode : 43339374 }
{ _id : 3, address : "2324 Pluto Place", zipCode : Long(3921412) }
{ _id : 4, address : "55 Saturn Ring", zipCode : 88602117 }

Querying by Multiple Data Types按多种数据类型查询

The grades collection contains names and averages, where classAverage has string, int, and double values:grades集合包含名称和平均值，其中classAverage具有string、int和double值：

db.grades.insertMany( [
      { _id : 1, name : "Alice King" , classAverage : 87.333333333333333 },
      { _id : 2, name : "Bob Jenkins", classAverage : "83.52" },
      { _id : 3, name : "Cathy Hart", classAverage: "94.06" },
      { _id : 4, name : "Drew Williams" , classAverage : Int32("93") }
] )

The following queries return all documents where classAverage is the BSON type string or double or is an array containing an element of the specified types. The first query uses numeric aliases while the second query uses string aliases.以下查询返回所有classAverage为BSON类型string或double或包含指定类型元素的数组的文档。第一个查询使用数字别名，而第二个查询使用字符串别名。

db.grades.find( { classAverage : { $type : [ 2 , 1 ] } } );
db.grades.find( { classAverage : { $type : [ "string" , "double" ] } } );

These queries return the following documents:这些查询返回以下文档：

{ _id : 1, name : "Alice King", classAverage : 87.33333333333333 }
{ _id : 2, name : "Bob Jenkins", classAverage : "83.52" }
{ _id : 3, name : "Cathy Hart", classAverage : "94.06" }

Querying by MinKey and MaxKey按MinKey和MaxKey查询

The restaurants collection uses minKey for any grade that is a failing grade:restaurants集合使用minKey表示任何不及格的分数：

db.restaurants.insertOne( [
   {
      _id: 1,
      address: {
         building: "230",
         coord: [ -73.996089, 40.675018 ],
         street: "Huntington St",
         zipcode: "11231"
      },
      borough: "Brooklyn",
      cuisine: "Bakery",
      grades: [
         { date : new Date(1393804800000), grade : "C", score : 15 },
         { date : new Date(1378857600000), grade : "C", score : 16 },
         { date : new Date(1358985600000), grade : MinKey(), score : 30 },
         { date : new Date(1322006400000), grade : "C", score : 15 }
      ],
      name : "Dirty Dan's Donuts",
      restaurant_id : "30075445"
   }
] )

And maxKey for any grade that is the highest passing grade:maxKey用于任何最高通过等级：

db.restaurants.insertOne( [
   {
      _id : 2,
      address : {
         building : "1166",
         coord : [ -73.955184, 40.738589 ],
         street : "Manhattan Ave",
         zipcode : "11222"
      },
      borough: "Brooklyn",
      cuisine: "Bakery",
      grades: [
         { date : new Date(1393804800000), grade : MaxKey(), score : 2 },
         { date : new Date(1378857600000), grade : "B", score : 6 },
         { date : new Date(1358985600000), grade : MaxKey(), score : 3 },
         { date : new Date(1322006400000), grade : "B", score : 5 }
      ],
      name : "Dainty Daisey's Donuts",
      restaurant_id : "30075449"
   }
] )

The following query returns any restaurant whose grades.grade field contains minKey or is an array containing an element of the specified type:以下查询返回其grades.grade字段包含minKey或是包含指定类型元素的数组的任何餐厅：

db.restaurants.find(
   { "grades.grade" : { $type : "minKey" } }
)

This returns the following results:这将返回以下结果：

{
   _id : 1,
   address : {
      building : "230",
      coord : [ -73.996089, 40.675018 ],
      street : "Huntington St",
      zipcode : "11231"
   },
   borough : "Brooklyn",
   cuisine : "Bakery",
   grades : [
      { date : ISODate("2014-03-03T00:00:00Z"), grade : "C", score : 15 },
      { date : ISODate("2013-09-11T00:00:00Z"), grade : "C", score : 16 },
      { date : ISODate("2013-01-24T00:00:00Z"), grade : { "$minKey" : 1 }, score : 30 },
      { date : ISODate("2011-11-23T00:00:00Z"), grade : "C", score : 15 }
   ],
   name : "Dirty Dan's Donuts",
   restaurant_id : "30075445"
}

The following query returns any restaurant whose grades.grade field contains maxKey or is an array containing an element of the specified type:以下查询返回其grades.grade字段包含maxKey或是包含指定类型元素的数组的任何餐厅：

db.restaurants.find(
   { "grades.grade" : { $type : "maxKey" } }
)

This returns the following results:这将返回以下结果：

{
   _id : 2,
   address : {
      building : "1166",
      coord : [ -73.955184, 40.738589 ],
      street : "Manhattan Ave",
      zipcode : "11222"
   },
   borough : "Brooklyn",
   cuisine : "Bakery",
   grades : [
      { date : ISODate("2014-03-03T00:00:00Z"), grade : { "$maxKey" : 1 }, score : 2 },
      { date : ISODate("2013-09-11T00:00:00Z"), grade : "B", score : 6 },
      { date : ISODate("2013-01-24T00:00:00Z"), grade : { "$maxKey" : 1 }, score : 3 },
      { date : ISODate("2011-11-23T00:00:00Z"), grade : "B", score : 5 }
   ],
   name : "Dainty Daisey's Donuts",
   restaurant_id : "30075449"
}