1. 哈希對象中key的順序

比如，你要存儲一個簡單的文字對象：:

> db.books.insert({ title: "Woe from Wit", meta: { author: "A. Griboyedov", year: 1823 } }); 

太棒了！現在我們有了一條書籍記錄。再比如，以后我們會想找所有1823年出版的作者是 A. Griboyedov 的書。這里不太可能返回多個結果，但至少應該有《 Woe from Wit 》這本書，因為我們剛剛插入了這條記錄，對不對？

> db.books.find({ meta: { year: 1823, author: "A. Griboyedov" } }); 
< No results returned 

發生了什么？我們不是剛剛插入了這本書的數據嗎？讓我們嘗試調換key的順序：

> db.books.find({ meta: { author: "A. Griboyedov", year: 1823 } }); 
< { _id: ..., title: "Woe from Wit", meta: { ... } } 

搞定了!

陷阱: 在MongoDB中key的順序非常重要，{ a: 1, b: 2 } 和 { b: 2, a: 1 }是不匹配的。

為什么: MongoDB使用叫做BSON的二進制數據格式。在BSON中key的順序非常重要。注意，JSON對象是一個無序的鍵/值對集合。

那么在JavaScript里是怎樣的呢？ECMA-262可沒有規定（JS屬性順序）這件事。在某些瀏覽器下（通常是舊的）對屬性的順序不會太在意，這意味著它們可以是任何順序（只要存在就行）。值得慶幸的是大多數現代瀏覽器的JavaScript引擎在維護JS屬性的順序（有時甚至在數組中也維護） ，因此實際上我們可以使用node.js來控制它。

更多內容請參閱 John Resig's blog.

問題的答案是：要么給出規范形式（鍵按字典順序排序） ，要么就使得你自己的代碼中是一致的。

當然，這里有其它的解決方法。使用另一種查詢方法（selector），即指定那些特定的屬性項（key-path），而不是比較對象的文本信息：

> db.books.find({ 'meta.year': 1823, 'meta.author': 'A. Griboyedov' }); 

這種特殊情況下這樣的查詢方式是有效地，但請注意，這個查詢語句的含義是不同的。

陷阱: 每當你想建立一個擁有多鍵值索引的數據的時候這種行為是很危險的。

> db.books.ensureIndex({ title: 1, 'meta.year': -1 }); 

這樣的命令會使得title的優先級會比 meta.year 的優先級高。這在MongoDB中是一個很重要的分析數據的方式。更多內容請參閱MongoDB docs.

2. undefined, null and undefined

想必很多人都還記得那個undefined, null 的關系、特性很混亂的時候吧！在JavaScript的世界中undefined、null代表著兩個不同的值，嚴格來說它們是不一樣 的：undefined！== NULL。當然，在非嚴格的情況下他們確實相等：undefined == null。有些人很小心的使用它們，而另一部分人將兩者隨意交替使用。說到底我們的問題是：JavaScript確實存在兩個不同但很相似的值。

MongoDB的帶來了它帶到一個新的水平。BSON里將未定義規定為"deprecated"。 BSON spec規定undefined為“deprecated”.

然而Node.js中的node-native-driver for MongoDB卻沒有實現它。

Node.js目前的版本（2.4.8）特性表明null和undefined是兩個相同的值。

> db.things.insert({ a: null, b: 1 }); 
> db.things.insert({ b: 2 }); // the 'a' is undefined implicitly 
> db.things.find({ a: null }); 
< { a: null, b: 1 } 
< { b: 2 } 

我不確定node driver for MongoDB中的實現情況，不過看起來像是node driver直接將undefined轉換為null，但是這在mongo-shell里是被限制的（因為在MongoDB里undefined和 null本來就是兩個值--譯者注）。

// from node.js code with mongo/node-native-driver 
    db.things.insert({ a: null, b: 1 }); 
    db.things.insert({ b: 2 }); 
    db.things.insert({ a: undefined, b: 3 }); 
    console.log(db.things.find({ a: null }).fetch()) 
    console.log(db.things.find({ a: undefined }).fetch()) 

然而，在mongo-shell中你只能使用null來查詢，注意，我們所使用的三個對象和上面的是一樣的。

// from mongo-shell 
> db.things.find({a: undefined}); 
< error: { "$err" : "can't have undefined in a query expression", "code" : 13629 } 
> db.things.find({a: null}); 
< { "a" : null, "b" : 1, "_id" : "wMWNPm7zrYXTNJpiA" } 
< { "b" : 2, "_id" : "RjrYvmZF5EukhpuAY" } 
< { "a" : null, "b" : 3, "_id" : "kethQ2khbyfFjJ7Sa" } 

我們可以看到，mongo/node-native-driver 顯式的將undefined轉換null但實際上左邊隱式的那個才是我們真正想要的（我們期望的真實結果）。

當我們使用mongo-shell顯式的插入undefined的時候，有趣的事情發生了：

// from mongo-shell 
    > db.things.insert({ a: undefined, b: 4 }); 
    > db.things.find({ a: null }) 
    < { "a" : null, "b" : 1, "_id" : "wMWNPm7zrYXTNJpiA" } 
    < { "b" : 2, "_id" : "RjrYvmZF5EukhpuAY" } 
    < { "a" : null, "b" : 3, "_id" : "kethQ2khbyfFjJ7Sa" } 

我們得到相同的三個值，但并沒有我們剛才在mongo-shell里插入的 b=4的對象。undefined不是和null相等嗎？好吧，讓我們來看看這個新的對象：

> db.things.find({ b: 4 }); 
< { "_id" : ObjectId("52ca134f3e47d3d91146f2b5"), "a" : null, "b" : 4 } 

它仍然在那里，雖然a屬性的值很像是null，但與我們的選擇器卻不匹配。

陷阱：有2個以上的值在MongoDB中看起來像null： null，undefined以及隱式的向mongo-shell里插入的undefined，雖然看起來像null但在實際情況下和BSON（第6版） 中的undefined 相匹配。***一個在選擇器上并不和null匹配，前兩者都匹配undefined和null。這也說明了沒有值同樣可以匹配前兩者。

原始問題請參閱 GitHub issue。

#p#

3. Soft limits, hard limits and no limits

你有一個項目的輸入并且允許用戶指定數字項目返回。你應該把問題的結果像這樣返回：

db.items.find({ ... }).limit(N); 

N值是由 用戶供給的。我們當然希望小心的將用戶限制在50之內，否則網絡上的任何人只需簡單地提供一個非常大的N值都可以下載我們的應用服務器和數據庫。

function getItems (N) { 
      if (N > 50) 
        N = 50; 
      return db.items.find({}).sort({ year: 1 }).limit(N); 
    } 

看起來是個有道理運行在你的node.js app上的代碼。

陷阱：如果用戶提供0作為一個項目的值，他希望MongoDB可以理解為把所有都給他。

這在文檔里寫的很清楚，但很多情況下并不是那么顯然：在MongoDB中零表示無限制。我猜想MongoDB的代碼可能將undefined, null, 0等等所有的false值當做無限制對待。

這沒關系，我們可以對0進行單獨處理：

function getItems (N) { 
      if (N > 50 || !N) // check if N is falsy ("no limit") 
        N = 50; 
      return db.items.find({}).sort({ year: 1 }).limit(N); 
    } 

看上去不錯？但是如果用戶輸入一個負值怎么辦？這可能么？這又意味著什么？

事實上像 db.items.find().limit(-1000000000000)這類的語句可能返回非常多的項。很難找到相關的文檔，但幾個月前我在 node.js的驅動文檔中看到一篇文章描述了這種行為，它將其表述為“硬”限制和“軟”限制。我不知道這是什么意思。 那么我們服務器端方法的最終版就是這樣了：

function getItems (N) { 
      if (N < 0) N = -N; 
      if (N > 50 || !N) // check if N is falsy ("no limit") 
        N = 50; 
      return db.items.find({}).sort({ year: 1 }).limit(N); 
    } 

總結： 限制可以是負數。它在廣義上和正數是一樣的但是負數限制是“軟限制”。

4.數組的特殊待遇

很多人并不知道這個特性，但數組確實是經過特殊處理的。

> db.c.insert({ a: [{x: 2}, {x: 3}], _id: "aaa"}) 
> db.c.find({'a.x': { $gt: 1 }}) 
< { "_id" : "aaa", "a" : [  {  "x" : 2 },  {  "x" : 3 } ] } 
> db.c.find({'a.x': { $gt: 2 }}) 
< { "_id" : "aaa", "a" : [  {  "x" : 2 },  {  "x" : 3 } ] } 
> db.c.find({'a.x': { $gt: 3 }}) 
< Nothing found 

因此每當有一個數組對象，選擇器都會“分發”給每一個元素，這就像“如果其中一個元素匹配，那么整個文檔（document)都會被匹配”。

值得注意的是，它并不適用于嵌套數組：

> db.x.insert({ _id: "bbb", b: [ [{x: 0}, {x: -1}], {x: 1} ] }) 
> db.x.find({ 'b.x': 1 }) 
< { "_id" : "bbb", "b" : [  [  {  "x" : 0 },  {  "x" : -1 } ],  {  "x" : 1 } ] } 
> db.x.find({ 'b.x': 0 }) 
< Nothing found 
> db.x.find({ 'b.x': -1 }) 
< Nothing found 

同樣也適用于預測數組中字段（field）的一些特性：

> db.z.insert({a:[[{b:1,c:2},{b:2,c:4}],{b:3,c:5},[{b:4, c:9}]]}) 
> db.z.find({}, {'a.b': 1}) 
< { "_id" : ObjectId("52ca24073e47d3d91146f2b7"), "a" : [  [  {  "b" : 1 },  {  "b" : 2 } ],  {  "b" : 3 },  [  {  "b" : 4 } ] ] } 

如果我們在選擇器上將以上特性與使用數字鍵做更多的組合，那么這個特性將變得越來越難以預測：

> db.z.insert({a: [[{x: "00"}, {x: "01"}], [{x: "10"}, {x: "11"}]], _id: "zzz"}) 
> db.z.find({'a.x': '00'}) 
< Nothing found 
> db.z.find({'a.x': '01'}) 
< Nothing found 
> db.z.find({'a.x': '10'}) 
< Nothing found 
> db.z.find({'a.x': '11'}) 
< Nothing found 
> db.z.find({'a.0.0.x': '00'}) 
< { "_id" : "zzz", "a" : [     [   {   "x" : "00" },   {   "x" : "01" } ],     [   {   "x" : "10" },   {   "x" : "11" } ] ] } 
> db.z.find({'a.0.0.x': '01'}) 
< Nothing found 
> db.z.find({'a.0.x': '00'}) 
< { "_id" : "zzz", "a" : [     [   {   "x" : "00" },   {   "x" : "01" } ],     [   {   "x" : "10" },   {   "x" : "11" } ] ] } 
> db.z.find({'a.0.x': '01'}) 
< { "_id" : "zzz", "a" : [     [   {   "x" : "00" },   {   "x" : "01" } ],     [   {   "x" : "10" },   {   "x" : "11" } ] ] } 
> db.z.find({'a.0.x': '10'}) 
< Nothing found 
> db.z.find({'a.0.x': '11'}) 
< Nothing found 
> db.z.find({'a.1.x': '00'}) 
< Nothing found 
> db.z.find({'a.1.x': '01'}) 
< Nothing found 
> db.z.find({'a.1.x': '10'}) 
< { "_id" : "zzz", "a" : [     [   {   "x" : "00" },   {   "x" : "01" } ],     [   {   "x" : "10" },   {   "x" : "11" } ] ] } 
> db.z.find({'a.1.x': '11'}) 
< { "_id" : "zzz", "a" : [ [ { "x" : "00" }, { "x" : "01" } ], [ { "x" : "10" }, { "x" : "11" } ] ] } 

好的，我們再來稍作改動。這個和上一個案例的區別僅僅是內部值的改動：在上一個案例中是一個對象，在下面的案例中將會是一個數字。這足以讓數組的特性發生改變：

> db.p.insert({a: [0], _id: "xxx"}) 
> db.p.find({'a': 0}) 
< { "_id" : "xxx", "a" : [  0 ] } 
> db.q.insert({a: [[0]], _id: "yyy"}) 
> db.q.find({a: 0}) 
< Nothing found 
> db.q.find({'a.0': 0}) 
< Nothing found 
> db.q.find({'a.0.0': 0}) 
< { "_id" : "yyy", "a" : [  [  0 ] ] } 

陷阱: 盡可能的避免數組或者嵌套數組以及其他一對多關系的數據存在于文檔之中，并且在需要查詢的時候，通常我們傾向 于按照一對一關系去查詢。然而對于使用數字鍵（例如{ 'a.0.x': Y }意味著字段a的***個元素的x字段必須為Y）的混合型文檔很可能會讓人感覺非常別扭，當然這也取決于數據的復雜程度。

#p#

5. 地理定位操作符$near

這個操作符很簡單。你擁有大量包含位置字段的文檔。位置字段表示的是地理位置信息。技巧就是MongoDB可以對兩種不同類型的位置信息進行索引，每種類型都有稍微不同的API和行為。

***種類型如下：

db.c.find({ 
  location: { 
    $near: [12.3, 32.1], 
    $maxDistance: 777 
  }}); 

第二種類型如下：

db.c.find({ 
  location: { 
    $near: { 
      $geometry: { 
        type: "Point", 
        coordinates: [ 12.3, 32.1 ] 
      }, 
      $maxDistance: 777 
    } 
  }}); 

對每個被索引類型來說，地理信息查詢語法稍稍有些不同。在通常所用的地理位置信息配對中$maxDistance與$near處于同等地位，而在Geo-JSON表示的地理位置信息配對中$maxDistance就是$near的子元素。
然而，還不止這些！有時你在結果集中會兩次獲得同一個位置點！為了能夠理解這一點，我們需要回想一下前一個嵌套數組里存在的缺陷?？纯聪旅娲a：

> db.c.insert({ location: [[1, 2], [1, 0]] }); // inserting an array of two points> db.c.ensureIndex({ location: "2d" }); 
> db.c.find({ location: { $near: [0, 0], $maxDistance: 500 } }); 
< { "_id" : ObjectId("52ca30ec3e47d3d91146f2b8"), "location" : [  [  1,  2 ],  [  1,  0 ] ] } 
< { "_id" : ObjectId("52ca30ec3e47d3d91146f2b8"), "location" : [  [  1,  2 ],  [  1,  0 ] ] } 

從匹配給定選擇子的數組里返回同一個位置點兩次，認為是兩個位置點。

原文鏈接：http://devblog.me/wtf-mongo

譯文鏈接：http://www.oschina.net/translate/wtf-mongo