1. 哈希對象中key的順序

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

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

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

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

發(fā)生了什么？我們不是剛剛插入了這本書的數(shù)據(jù)嗎？讓我們嘗試調(diào)換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的二進制數(shù)據(jù)格式。在BSON中key的順序非常重要。注意，JSON對象是一個無序的鍵/值對集合。

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

更多內(nèi)容請參閱 John Resig's blog.

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

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

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

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

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

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

這樣的命令會使得title的優(yōu)先級會比 meta.year 的優(yōu)先級高。這在MongoDB中是一個很重要的分析數(shù)據(jù)的方式。更多內(nèi)容請參閱MongoDB docs.

2. undefined, null and undefined

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

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

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

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中的實現(xiàn)情況，不過看起來像是node driver直接將undefined轉(zhuǎn)換為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轉(zhuǎn)換null但實際上左邊隱式的那個才是我們真正想要的（我們期望的真實結(jié)果）。

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

// 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

你有一個項目的輸入并且允許用戶指定數(shù)字項目返回。你應(yīng)該把問題的結(jié)果像這樣返回：

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

N值是由 用戶供給的。我們當(dāng)然希望小心的將用戶限制在50之內(nèi)，否則網(wǎng)絡(luò)上的任何人只需簡單地提供一個非常大的N值都可以下載我們的應(yīng)用服務(wù)器和數(shù)據(jù)庫。

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值當(dāng)做無限制對待。

這沒關(guān)系，我們可以對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)這類的語句可能返回非常多的項。很難找到相關(guān)的文檔，但幾個月前我在 node.js的驅(qū)動文檔中看到一篇文章描述了這種行為，它將其表述為“硬”限制和“軟”限制。我不知道這是什么意思。 那么我們服務(wù)器端方法的最終版就是這樣了：

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); 
    } 

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

4.數(shù)組的特殊待遇

很多人并不知道這個特性，但數(shù)組確實是經(jīng)過特殊處理的。

> 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 

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

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

> 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 

同樣也適用于預(yù)測數(shù)組中字段（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 } ] ] } 

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

> 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" } ] ] } 

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

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

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

#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的子元素。
然而，還不止這些！有時你在結(jié)果集中會兩次獲得同一個位置點！為了能夠理解這一點，我們需要回想一下前一個嵌套數(shù)組里存在的缺陷。看看下面代碼：

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

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

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

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