原教程地址

Nedb——Node嵌入式数据库

简单demo

<template>
    <div>
        <el-button type="primary" @click="addOneUser">添加用户</el-button>
        <el-button type="primary" @click="search">查询</el-button>
    </div>
</template>

<script>
// 导入相关方法
import Datastore from 'nedb';
let db = new Datastore({ filename: './db/user.db', autoload: true });
export default {
    data() {
        return {

        };
    },
    methods: {
        // 添加一个用户
        addOneUser() {
            db.loadDatabase(function (err) {
                // 回调函数(可选)
                console.error('nedb加载失败：', err);
            });
            let doc = {
                name: '张大三',
                age: 15
            };
            db.insert(doc, function (err, newDoc) {
                if(err) {
                    console.log('插入失败！');
                }else{
                    console.log('成功：',newDoc);
                }
            });
        },
        // 查询用户列表
        search() {
            db.find({}, function (err, docs) {
                if(!err) {
                    console.log(docs);
                }
            });
        }
    }
};
</script>

<style scoped lang="scss">

</style>

在这里遇到了个问题，指定了数据库地址，但是数据直接保存到了内存里，只能通过控制台打印的方式输出。
然后我单独建立一个node的demo，数据会保存的本地，但是存在一个问题。数据会保存在执行插入命令文件的同级目录下。

基本使用

简介

NeDB是使用Nodejs实现的一个NoSQL嵌入式数据库操作模块，可以充当内存数据库，也可以用来实现本地存储，甚至可以在浏览器中使用。查询方式比较灵活，支持使用正则、比较运算符、逻辑运算符、索引以及JSON深度查询等。

NeDB嵌入到了应用程序进程中，消除了与客户机服务器配置相关的开销，在运行时，也只需要较少的内存开销，使用精简代码编写，速度更快。其API是MongoDB的一个子集，可以通过这些接口轻松管理应用程序数据，而不依靠原始的文档文件。

具有简单、轻量、速度快等特点，由于嵌入式数据库存储总数据量最好要控制在1GB以内，所以适合在不需要大量数据处理的应用系统中使用。

安装

npm install nedb --save

创建数据库

教程

new Datastore(options)

作用：
初始化一个数据存储，相当于MongoDB的一个集合、Mysql的一张表。
options对象配置参数：
① filename(可选): 数据存储文件路径。如果为空，数据将会自动存储在内存中。注意路径不能以“~”结尾。
② inMemoryOnly(可选,默认false): 数据存储方式。是否只存在于内存中。
③ loadDatabase: 将数据加载到内存中。
④ timestampData(可选,默认false): 自动生成时间戳，字段为createdAt和updateAt，用来记录文档插入和更新操作的时间点。
⑤ autoload(可选,默认false): 如果使用autoload，当数据存储被创建时，数据将自动从文件中加载到内存，不必去调用loadDatabase。注意所有命令操作只有在数据加载完成后才会被执行。
⑥ onl oad(可选): 在数据加载完成后被调用，也就是在loadDatabase方法调用后触发。该方法有一个error参数，如果试用了autoload，而且没有定义该方法，在数据加载过程中出错将默认会抛出该错误。
⑦ afterSerialization(可选): 在数据被序列化成字符串之后和被写入磁盘前，可以使用该方法对数据进行转换。比如可以做一些数据加密工作。该方法入参为一个字符串(绝对不能含有字符“\n”，否则数据会丢失)，返回转换后的字符串。
⑧ beforeDeserialization(可选): 与afterSerialization相反。两个必须成对出现，否则会引起数据丢失，可以理解为一个加密解密的过程。
⑨ corruptAlertThreshold(可选): 默认10%,取值在0-1之间。如果数据文件损坏率超过这个百分比，NeDB将不会启动。取0，意味着不能容忍任何数据损坏；取1，意味着忽略数据损坏问题。
⑩ compareStrings(可选): compareStrings(a, b)比较两个字符串，返回-1、0或者1。如果被定义，将会覆盖默认的字符串比较方法，用来兼容默认方法不能比较非US字符的缺点。
注：如果使用本地存储，而且没有配置autoload参数，需要手动调用loadDatabase方法，所有操作(insert, find, update, remove)在该方法被调用前都不会执行。还有就是，如果loadDatabase失败，所有命令也将不会执行。

// 示例 1: 内存数据库(没有必要调用loadDatabase方法)
var Datastore = require('nedb'),
    db = new Datastore();
 
 
// 示例 2: 本地存储需要手动调用loadDatabase方法
var Datastore = require('nedb'),
    db = new Datastore({ filename: 'path/to/datafile' });
db.loadDatabase(function (err) {    // 回调函数(可选)
  // Now commands will be executed
});
 
 
// 示例 3: 带有autoload配置项的本地存储
var Datastore = require('nedb'),
    db = new Datastore({ filename: 'path/to/datafile', autoload: true });
// You can issue commands right away
 
 
// 示例 4: 创建多个数据存储
db = {};
db.users = new Datastore('path/to/users.db');
db.robots = new Datastore('path/to/robots.db');
 
// 如果不配置autoload，需要加载数据库(该方法是异步的)
db.users.loadDatabase();
db.robots.loadDatabase();

插入

db.insert()

db.insert(doc, callback)
作用：
插入文档数据(文档相当于mysql表中的一条记录)。如果文档不包含_id字段，NeDB会自动生成一个，该字段是16个字符长度的数字字符串。该字段一旦确定，就不能被更改。
参数：
doc: 支持String, Number, Boolean, Date, null, array以及object类型。如果该字段是undefined类型，将不会被保存，这里和MongoDB处理方式有点不同，MongoDB会将undefined转换为null进行存储。字段名称不能以"$“开始，也不能包含”."。
callback(可选): 回调函数，包含参数err以及newDoc，err是报错，newDoc是新插入的文档，包含它的_id字段。

var doc = { hello: 'world'
               , n: 5
               , today: new Date()
               , nedbIsAwesome: true
               , notthere: null
               , notToBeSaved: undefined  // 该字段不会被保存
               , fruits: [ 'apple', 'orange', 'pear' ]
               , infos: { name: 'nedb' }
               };
 
db.insert(doc, function (err, newDoc) {   // Callback is optional
  // newDoc is the newly inserted document, including its _id
  // newDoc has no key called notToBeSaved since its value was undefined
});
 
// 使用array，实现批量插入。一旦其中一个操作失败，所有改变将会回滚。
db.insert([{ a: 5 }, { a: 42 }], function (err, newDocs) {
  // Two documents were inserted in the database
  // newDocs is an array with these documents, augmented with their _id
});
 
// 如果a字段有唯一性约束，该操作将会执行失败。
db.insert([{ a: 5 }, { a: 42 }, { a: 5 }], function (err) {
  // err is a 'uniqueViolated' error
  // The database was not modified
});

查询
db.find()

db.find(query, callback)
作用：
查询符合条件的文档集。
参数：
query： object类型，查询条件。支持使用比较运算符($lt, $lte, $gt, $gte, $in, $nin, n e ) , 逻 辑 运 算 符 ( ne), 逻辑运算符( ne),逻辑运算符(or, $and, $not, $where), 正则表达式进行查询。
callback(可选): 回调函数，包含参数err以及docs，err是报错，docs是查询到的文档集。

// 数据存储集合
 
// { _id: 'id1', planet: 'Mars', system: 'solar', inhabited: false, satellites: ['Phobos', 'Deimos'] }
// { _id: 'id2', planet: 'Earth', system: 'solar', inhabited: true, humans: { genders: 2, eyes: true } }
// { _id: 'id3', planet: 'Jupiter', system: 'solar', inhabited: false }
// { _id: 'id4', planet: 'Omicron Persei 8', system: 'futurama', inhabited: true, humans: { genders: 7 } }
// { _id: 'id5', completeData: { planets: [ { name: 'Earth', number: 3 }, { name: 'Mars', number: 2 }, { name: 'Pluton', number: 9 } ] } }
 
// 示例1： 基本查询。可以使用正则表达式匹配字符串。使用“.”匹配对象或者数组里面的元素。
 
// 单字段查询
db.find({ system: 'solar' }, function (err, docs) {
});
 
// 正则表达式查询
db.find({ planet: /ar/ }, function (err, docs) {
  // docs contains Mars and Earth
});
 
// 多条件查询
db.find({ system: 'solar', inhabited: true }, function (err, docs) {
  // docs is an array containing document Earth only
});
 
// 根据对象属性查询
db.find({ "humans.genders": 2 }, function (err, docs) {
  // docs contains Earth
});
 
// 根据数组对象属性查询
db.find({ "completeData.planets.name": "Mars" }, function (err, docs) {
  // docs contains document 5
});
 
db.find({ "completeData.planets.name": "Jupiter" }, function (err, docs) {
  // docs is empty
});
 
db.find({ "completeData.planets.0.name": "Earth" }, function (err, docs) {
  // docs contains document 5
  // If we had tested against "Mars" docs would be empty because we are matching against a specific array element
});
 
 
// 对象深度比较查询，不要与"."使用混淆
db.find({ humans: { genders: 2 } }, function (err, docs) {
  // docs is empty, because { genders: 2 } is not equal to { genders: 2, eyes: true }
});
 
// 查询所有结果集
db.find({}, function (err, docs) {
});
 
// 查询某一个文档
db.findOne({ _id: 'id1' }, function (err, doc) {
  // doc is the document Mars
  // If no document is found, doc is null
});
 
 
// 示例2： {field: {$op: value}} ($op代表任意比较运算符)
// $lt, $lte: 小于，小于等于
// $gt, $gte: 大于，大于等于
// $in: 属于
// $ne, $nin: 不等于，不属于
// $exists: 取值为true或者false，用于检测文档是否具有某一字段
// $regex: 检测字符串是否与正则表达式相匹配
 
// $lt, $lte, $gt and $gte 只能用于数字和字符串类型
db.find({ "humans.genders": { $gt: 5 } }, function (err, docs) {
  // docs contains Omicron Persei 8, whose humans have more than 5 genders (7).
});
 
// 当进行字符串比较的时候，将使用字典序。
db.find({ planet: { $gt: 'Mercury' }}, function (err, docs) {
  // docs contains Omicron Persei 8
})
 
// Using $in. $nin is used in the same way
db.find({ planet: { $in: ['Earth', 'Jupiter'] }}, function (err, docs) {
  // docs contains Earth and Jupiter
});
 
// Using $exists
db.find({ satellites: { $exists: true } }, function (err, docs) {
  // docs contains only Mars
});
 
// Using $regex with another operator
db.find({ planet: { $regex: /ar/, $nin: ['Jupiter', 'Earth'] } }, function (err, docs) {
  // docs only contains Mars because Earth was excluded from the match by $nin
});
 
 
// 示例3： 当文档中有一个字段是数组，NeDB将首先判断查询值是否为数组，如果是数组的话将执行精确查找，然后再去判断是否存在数组比较方法(现在只支持$size和$elemMatch)。如果都没有，将会对所有元素进行查询。
// $size: 匹配数组的大小
// $elemMatch: 匹配至少一个数组元素
 
// 精确查找
db.find({ satellites: ['Phobos', 'Deimos'] }, function (err, docs) {
  // docs contains Mars
})
db.find({ satellites: ['Deimos', 'Phobos'] }, function (err, docs) {
  // docs is empty
})
 
// 使用数组比较方法
// $elemMatch 运算符将匹配数组中满足所有条件的元素
db.find({ completeData: { planets: { $elemMatch: { name: 'Earth', number: 3 } } } }, function (err, docs) {
  // docs contains documents with id 5 (completeData)
});
 
db.find({ completeData: { planets: { $elemMatch: { name: 'Earth', number: 5 } } } }, function (err, docs) {
  // docs is empty
});
 
// 在$elemMatch中使用比较运算符
db.find({ completeData: { planets: { $elemMatch: { name: 'Earth', number: { $gt: 2 } } } } }, function (err, docs) {
  // docs contains documents with id 5 (completeData)
});
 
// 注意不能使用嵌套的运算符, e.g. { $size: { $lt: 5 } } 将会抛出异常
db.find({ satellites: { $size: 2 } }, function (err, docs) {
  // docs contains Mars
});
 
db.find({ satellites: { $size: 1 } }, function (err, docs) {
  // docs is empty
});
 
// If a document's field is an array, matching it means matching any element of the array
db.find({ satellites: 'Phobos' }, function (err, docs) {
  // docs contains Mars. Result would have been the same if query had been { satellites: 'Deimos' }
});
 
// This also works for queries that use comparison operators
db.find({ satellites: { $lt: 'Amos' } }, function (err, docs) {
  // docs is empty since Phobos and Deimos are after Amos in lexicographical order
});
 
// This also works with the $in and $nin operator
db.find({ satellites: { $in: ['Moon', 'Deimos'] } }, function (err, docs) {
  // docs contains Mars (the Earth document is not complete!)
});
 
// 示例4： 逻辑运算符 $or, $and, $not, $where
// $or, $and: 并集，交集 { $op: [query1, query2, ...] }
// $not: 取非 { $not: query }
// $where: 条件 { $where: function () { /* object is "this", return a boolean */ } }
 
db.find({ $or: [{ planet: 'Earth' }, { planet: 'Mars' }] }, function (err, docs) {
  // docs contains Earth and Mars
});
 
db.find({ $not: { planet: 'Earth' } }, function (err, docs) {
  // docs contains Mars, Jupiter, Omicron Persei 8
});
 
db.find({ $where: function () { return Object.keys(this) > 6; } }, function (err, docs) {
  // docs with more than 6 properties
});
 
// You can mix normal queries, comparison queries and logical operators
db.find({ $or: [{ planet: 'Earth' }, { planet: 'Mars' }], inhabited: true }, function (err, docs) {
  // docs contains Earth
});
 
// 示例5: Projections
// 在第二个参数传入projections对象，来规定返回字段。比如： {a:1, b:1}指定只返回a和b字段，{a:0, b:0}指定省略a和b这两个字段。
// _id默认返回，不需要返回设置_id: 0
 
// Same database as above
 
// Keeping only the given fields
db.find({ planet: 'Mars' }, { planet: 1, system: 1 }, function (err, docs) {
  // docs is [{ planet: 'Mars', system: 'solar', _id: 'id1' }]
});
 
// Keeping only the given fields but removing _id
db.find({ planet: 'Mars' }, { planet: 1, system: 1, _id: 0 }, function (err, docs) {
  // docs is [{ planet: 'Mars', system: 'solar' }]
});
 
// Omitting only the given fields and removing _id
db.find({ planet: 'Mars' }, { planet: 0, system: 0, _id: 0 }, function (err, docs) {
  // docs is [{ inhabited: false, satellites: ['Phobos', 'Deimos'] }]
});
 
// Failure: using both modes at the same time
db.find({ planet: 'Mars' }, { planet: 0, system: 1 }, function (err, docs) {
  // err is the error message, docs is undefined
});
 
// You can also use it in a Cursor way but this syntax is not compatible with MongoDB
db.find({ planet: 'Mars' }).projection({ planet: 1, system: 1 }).exec(function (err, docs) {
  // docs is [{ planet: 'Mars', system: 'solar', _id: 'id1' }]
});
 
// Project on a nested document
db.findOne({ planet: 'Earth' }).projection({ planet: 1, 'humans.genders': 1 }).exec(function (err, doc) {
  // doc is { planet: 'Earth', _id: 'id2', humans: { genders: 2 } }
});
 
// 示例6：排序和分页
 
// 文档集
// doc1 = { _id: 'id1', planet: 'Mars', system: 'solar', inhabited: false, satellites: ['Phobos', 'Deimos'] }
// doc2 = { _id: 'id2', planet: 'Earth', system: 'solar', inhabited: true, humans: { genders: 2, eyes: true } }
// doc3 = { _id: 'id3', planet: 'Jupiter', system: 'solar', inhabited: false }
// doc4 = { _id: 'id4', planet: 'Omicron Persei 8', system: 'futurama', inhabited: true, humans: { genders: 7 } }
 
// No query used means all results are returned (before the Cursor modifiers)
db.find({}).sort({ planet: 1 }).skip(1).limit(2).exec(function (err, docs) {
  // docs is [doc3, doc1]
});
 
// You can sort in reverse order like this
db.find({ system: 'solar' }).sort({ planet: -1 }).exec(function (err, docs) {
  // docs is [doc1, doc3, doc2]
});
 
// You can sort on one field, then another, and so on like this:
db.find({}).sort({ firstField: 1, secondField: -1 }) ...   // You understand how this works!

更新

db.update()

db.update(query, update, options, callback)
作用：
根据update参数的规则，更新匹配到query的结果集。
参数：
query: 与find和findOne中query参数的用法一致
update: 指定文档更改规则。该参数可以是一个新的文档，也可以是一套修饰符，两者不能同时使用。使用修饰符时，如果需要更改的字段不存在，将会自动创建。可用的修饰符有$set(改变字段值), $unset(删除某一字段), $inc(增加某一字段), m i n / min/ min/max(改变字段值，传入值需要小于/大于当前值), 还有一些用在数组上的修饰符，$push, $pop, $addTopSet, $pull, $each, $slice，具体用法如下示例。
options: object类型。muti(默认false)，是否允许修改多条文档；upsert(默认为false)，如果query没有匹配到结果集，有两种情况需要考虑，一个是update是一个简单的对象(不包含任何修饰符)，另一种情况是带有修饰符，对第一种情况会直接将该文档插入，对第二种情况会将通过修饰符更改后的文档插入；
callback(可选): 参数(err, numAffected, affectedDocuments, upsert)。numAffected：被影响的文档个数；affectedDocuments：更新后的文档。
注意：_id不能被修改

// 文档集
// { _id: 'id1', planet: 'Mars', system: 'solar', inhabited: false }
// { _id: 'id2', planet: 'Earth', system: 'solar', inhabited: true }
// { _id: 'id3', planet: 'Jupiter', system: 'solar', inhabited: false }
// { _id: 'id4', planet: 'Omicron Persia 8', system: 'futurama', inhabited: true }
 
// 用一个文档替换另一个文档
db.update({ planet: 'Jupiter' }, { planet: 'Pluton'}, {}, function (err, numReplaced) {
  // numReplaced = 1
  // The doc #3 has been replaced by { _id: 'id3', planet: 'Pluton' }
  // Note that the _id is kept unchanged, and the document has been replaced
  // (the 'system' and inhabited fields are not here anymore)
});
 
// 设定一个已存字段的值
db.update({ system: 'solar' }, { $set: { system: 'solar system' } }, { multi: true }, function (err, numReplaced) {
  // numReplaced = 3
  // Field 'system' on Mars, Earth, Jupiter now has value 'solar system'
});
 
// 设定一个不存在字段的值
db.update({ planet: 'Mars' }, { $set: { "data.satellites": 2, "data.red": true } }, {}, function () {
  // Mars document now is { _id: 'id1', system: 'solar', inhabited: false
  //                      , data: { satellites: 2, red: true }
  //                      }
  // Not that to set fields in subdocuments, you HAVE to use dot-notation
  // Using object-notation will just replace the top-level field
  db.update({ planet: 'Mars' }, { $set: { data: { satellites: 3 } } }, {}, function () {
    // Mars document now is { _id: 'id1', system: 'solar', inhabited: false
    //                      , data: { satellites: 3 }
    //                      }
    // You lost the "data.red" field which is probably not the intended behavior
  });
});
 
// 删除一个字段
db.update({ planet: 'Mars' }, { $unset: { planet: true } }, {}, function () {
  // Now the document for Mars doesn't contain the planet field
  // You can unset nested fields with the dot notation of course
});
 
// 设置upsert
db.update({ planet: 'Pluton' }, { planet: 'Pluton', inhabited: false }, { upsert: true }, function (err, numReplaced, upsert) {
  // numReplaced = 1, upsert = { _id: 'id5', planet: 'Pluton', inhabited: false }
  // A new document { _id: 'id5', planet: 'Pluton', inhabited: false } has been added to the collection
});
 
// If you upsert with a modifier, the upserted doc is the query modified by the modifier
// This is simpler than it sounds :)
db.update({ planet: 'Pluton' }, { $inc: { distance: 38 } }, { upsert: true }, function () {
  // A new document { _id: 'id5', planet: 'Pluton', distance: 38 } has been added to the collection  
});
 
// If we insert a new document { _id: 'id6', fruits: ['apple', 'orange', 'pear'] } in the collection,
// let's see how we can modify the array field atomically
 
// $push inserts new elements at the end of the array
db.update({ _id: 'id6' }, { $push: { fruits: 'banana' } }, {}, function () {
  // Now the fruits array is ['apple', 'orange', 'pear', 'banana']
});
 
// $pop removes an element from the end (if used with 1) or the front (if used with -1) of the array
db.update({ _id: 'id6' }, { $pop: { fruits: 1 } }, {}, function () {
  // Now the fruits array is ['apple', 'orange']
  // With { $pop: { fruits: -1 } }, it would have been ['orange', 'pear']
});
 
// $addToSet adds an element to an array only if it isn't already in it
// Equality is deep-checked (i.e. $addToSet will not insert an object in an array already containing the same object)
// Note that it doesn't check whether the array contained duplicates before or not
db.update({ _id: 'id6' }, { $addToSet: { fruits: 'apple' } }, {}, function () {
  // The fruits array didn't change
  // If we had used a fruit not in the array, e.g. 'banana', it would have been added to the array
});
 
// $pull removes all values matching a value or even any NeDB query from the array
db.update({ _id: 'id6' }, { $pull: { fruits: 'apple' } }, {}, function () {
  // Now the fruits array is ['orange', 'pear']
});
db.update({ _id: 'id6' }, { $pull: { fruits: $in: ['apple', 'pear'] } }, {}, function () {
  // Now the fruits array is ['orange']
});
 
// $each can be used to $push or $addToSet multiple values at once
// This example works the same way with $addToSet
db.update({ _id: 'id6' }, { $push: { fruits: { $each: ['banana', 'orange'] } } }, {}, function () {
  // Now the fruits array is ['apple', 'orange', 'pear', 'banana', 'orange']
});
 
// $slice can be used in cunjunction with $push and $each to limit the size of the resulting array.
// A value of 0 will update the array to an empty array. A positive value n will keep only the n first elements
// A negative value -n will keep only the last n elements.
// If $slice is specified but not $each, $each is set to []
db.update({ _id: 'id6' }, { $push: { fruits: { $each: ['banana'], $slice: 2 } } }, {}, function () {
  // Now the fruits array is ['apple', 'orange']
});
 
// $min/$max to update only if provided value is less/greater than current value
// Let's say the database contains this document
// doc = { _id: 'id', name: 'Name', value: 5 }
db.update({ _id: 'id1' }, { $min: { value: 2 } }, {}, function () {
  // The document will be updated to { _id: 'id', name: 'Name', value: 2 }
});
 
db.update({ _id: 'id1' }, { $min: { value: 8 } }, {}, function () {
  // The document will not be modified
});

删除
db.remove()

db.remove(query, options, callback)
作用：
根据options配置删除所有query匹配到的文档集。
参数：
query: 与find和findOne中query参数的用法一致
options: 只有一个可用。muti(默认false)，允许删除多个文档。
callback: 可选，参数: err, numRemoved

// 文档集
// { _id: 'id1', planet: 'Mars', system: 'solar', inhabited: false }
// { _id: 'id2', planet: 'Earth', system: 'solar', inhabited: true }
// { _id: 'id3', planet: 'Jupiter', system: 'solar', inhabited: false }
// { _id: 'id4', planet: 'Omicron Persia 8', system: 'futurama', inhabited: true }
 
// 删除一条记录
// options set to {} since the default for multi is false
db.remove({ _id: 'id2' }, {}, function (err, numRemoved) {
  // numRemoved = 1
});
 
// 删除多条记录
db.remove({ system: 'solar' }, { multi: true }, function (err, numRemoved) {
  // numRemoved = 3
  // All planets from the solar system were removed
});
 
// 删除所有记录
db.remove({}, { multi: true }, function (err, numRemoved) {
});

索引
db.ensureIndex()

db.ensureIndex(options, callback)
作用：
NeDB支持索引。索引可以提高查询速度以及保证字段的唯一性。索引可以用在任何字段，包括嵌套很深的字段。目前，索引只能用来加速基本查询以及使用$in, $lt, $lte, $gt 和 $gte运算符的查询，如上find接口中示例所示。保证索引不为数组对象。方法可以在任何时候被调用，推荐在应用启动时就调用(该方法是同步的,为1000个文档添加索引仅需35ms)。
参数：
fieldName(必须): 索引字段，使用“.”给嵌套的字段加索引。
unique(可选，默认false): 字段唯一性约束。注意：唯一性约束会增加为两个文档中没有定义的字段添加索引的错误。
sparse(可选，默认false): 不能为没有定义的字段加索引。如果接受给多个文档中没有定义的字段添加索引，给需要该配置参数与unique一起使用。
expireAfterSeconds(可选，秒数): TTL索引，设置自动过期时间。
删除索引： db.removeIndex(fieldName, cb)
注意：_id字段会自动加索引和唯一性约束，不必再为它使用ensureIndex。如果使用本地存储，索引也将保存在数据文件中，当第二次加载数据库时，索引也将自动被添加。如果加载一个已经有索引的数据库，删除索引将不起任何作用。

db.ensureIndex({ fieldName: 'somefield' }, function (err) {
  // If there was an error, err is not null
});
 
// 对索引设置唯一性约束
db.ensureIndex({ fieldName: 'somefield', unique: true }, function (err) {
});
 
// Using a sparse unique index
db.ensureIndex({ fieldName: 'somefield', unique: true, sparse: true }, function (err) {
});
 
 
// 使用唯一性约束制造错误，查看err的格式
db.insert({ somefield: 'nedb' }, function (err) {
  // err is null
  db.insert({ somefield: 'nedb' }, function (err) {
    // err is { errorType: 'uniqueViolated'
    //        , key: 'name'
    //        , message: 'Unique constraint violated for key name' }
  });
});
 
// 移除somefield字段的索引
db.removeIndex('somefield', function (err) {
});
 
// Example of using expireAfterSeconds to remove documents 1 hour
// after their creation (db's timestampData option is true here)
db.ensureIndex({ fieldName: 'createdAt', expireAfterSeconds: 3600 }, function (err) {
});
 
// You can also use the option to set an expiration date like so
db.ensureIndex({ fieldName: 'expirationDate', expireAfterSeconds: 0 }, function (err) {
  // Now all documents will expire when system time reaches the date in their
  // expirationDate field
});

计数
db.count()

// Count all planets in the solar system
db.count({ system: 'solar' }, function (err, count) {
  // count equals to 3
});
 
// Count all documents in the datastore
db.count({}, function (err, count) {
  // count equals to 4
});