@abtnode/nedb 中文文档教程

Question

The JavaScript Database

Node.js 的嵌入式持久性或内存数据库。 js、nw.js、Electron 和浏览器，100% JavaScript，无二进制依赖。 API 是 MongoDB 的一个子集，它非常快。

重要提示：请不要提交与您的代码有关的问题。 只会回答实际的错误或功能请求，所有其他问题将在不发表评论的情况下关闭。 此外，请遵循错误报告指南并检查在提交已修复的错误之前更改日志 :)

Support NeDB development

没时间帮忙？ 您可以通过汇款或比特币来支持 NeDB 的发展！

金钱：

比特币地址：1dDZLnWpBbodPiN8sizzYrgaz5iahFyb1

Installation, tests

模块npm 和 bower 上的名称是 nedb。

npm install @abtnode/nedb --save    # Put latest version in your package.json
npm test                   # You'll need the dev dependencies to launch tests

API

它是 MongoDB API（最常用的操作）的一个子集。

• Creating/loading a database
• Persistence
• Inserting documents
• Finding documents
• Basic Querying
• Operators ($lt, $lte, $gt, $gte, $in, $nin, $ne, $exists, \$regex)
• Array fields
• Logical operators $or, $and, $not, $where
• Sorting and paginating
• Projections
• Counting documents
• Updating documents
• Removing documents
• Indexing
• Browser version

Creating/loading a database

您可以将 NeDB 用作仅内存中的数据存储或用作持久性数据存储。 一个数据存储相当于一个 MongoDB 集合。 构造函数按如下方式使用 new Datastore(options) 其中 options 是具有以下字段的对象：

• filename (optional): path to the file where the data is persisted. If left blank, the datastore is automatically considered in-memory only. It cannot end with a ~ which is used in the temporary files NeDB uses to perform crash-safe writes.
• inMemoryOnly (optional, defaults to false): as the name implies.
• timestampData (optional, defaults to false): timestamp the insertion and last update of all documents, with the fields createdAt and updatedAt. User-specified values override automatic generation, usually useful for testing.
• autoload (optional, defaults to false): if used, the database will automatically be loaded from the datafile upon creation (you don't need to call loadDatabase). Any command issued before load is finished is buffered and will be executed when load is done.
• onload (optional): if you use autoloading, this is the handler called after the loadDatabase. It takes one error argument. If you use autoloading without specifying this handler, and an error happens during load, an error will be thrown.
• afterSerialization (optional): hook you can use to transform data after it was serialized and before it is written to disk. Can be used for example to encrypt data before writing database to disk. This function takes a string as parameter (one line of an NeDB data file) and outputs the transformed string, which must absolutely not contain a \n character (or data will be lost).
• beforeDeserialization (optional): inverse of afterSerialization. Make sure to include both and not just one or you risk data loss. For the same reason, make sure both functions are inverses of one another. Some failsafe mechanisms are in place to prevent data loss if you misuse the serialization hooks: NeDB checks that never one is declared without the other, and checks that they are reverse of one another by testing on random strings of various lengths. In addition, if too much data is detected as corrupt, NeDB will refuse to start as it could mean you're not using the deserialization hook corresponding to the serialization hook used before (see below).
• corruptAlertThreshold (optional): between 0 and 1, defaults to 10%. NeDB will refuse to start if more than this percentage of the datafile is corrupt. 0 means you don't tolerate any corruption, 1 means you don't care.
• compareStrings (optional): function compareStrings(a, b) compares strings a and b and return -1, 0 or 1. If specified, it overrides default string comparison which is not well adapted to non-US characters in particular accented letters. Native localCompare will most of the time be the right choice
• nodeWebkitAppName (optional, DEPRECATED): if you are using NeDB from whithin a Node Webkit app, specify its name (the same one you use in the package.json) in this field and the filename will be relative to the directory Node Webkit uses to store the rest of the application's data (local storage etc.). It works on Linux, OS X and Windows. Now that you can use require('nw.gui').App.dataPath in Node Webkit to get the path to the data directory for your application, you should not use this option anymore and it will be removed.

如果您使用没有 autoload 选项，您需要手动调用 loadDatabase。 此函数从数据文件中获取数据并准备数据库。 别忘了！如果您使用 持久数据存储，在 loadDatabase 之前不会执行任何命令（插入、查找、更新、删除） 被调用，因此请确保自己调用它或使用 autoload 选项。

此外，如果 loadDatabase 失败，则之后注册到执行程序的所有命令都不会执行。 只有在 loadDatabase 成功之后，它们才会按顺序被注册和执行。

// Type 1: In-memory only datastore (no need to load the database)
var Datastore = require('@abtnode/nedb'),
  db = new Datastore();

// Type 2: Persistent datastore with manual loading
var Datastore = require('@abtnode/nedb'),
  db = new Datastore({ filename: 'path/to/datafile' });
db.loadDatabase(function (err) {
  // Callback is optional
  // Now commands will be executed
});

// Type 3: Persistent datastore with automatic loading
var Datastore = require('@abtnode/nedb'),
  db = new Datastore({ filename: 'path/to/datafile', autoload: true });
// You can issue commands right away

// Type 4: Persistent datastore for a Node Webkit app called 'nwtest'
// For example on Linux, the datafile will be ~/.config/nwtest/nedb-data/something.db
var Datastore = require('@abtnode/nedb'),
  path = require('path'),
  db = new Datastore({ filename: path.join(require('nw.gui').App.dataPath, 'something.db') });

// Of course you can create multiple datastores if you need several
// collections. In this case it's usually a good idea to use autoload for all collections.
db = {};
db.users = new Datastore('path/to/users.db');
db.robots = new Datastore('path/to/robots.db');

// You need to load each database (here we do it asynchronously)
db.users.loadDatabase();
db.robots.loadDatabase();

Persistence

在幕后，NeDB 的持久性使用仅附加格式，这意味着出于性能原因，所有更新和删除实际上都会导致在数据文件末尾添加行。 每次您在应用程序中加载每个数据库时，数据库都会自动压缩（即恢复为每文档一行）。

您可以使用不带参数的 yourDatabase.persistence.compactDatafile 手动调用压缩函数。 它将执行器中的数据文件压缩排队，在所有未决操作之后按顺序执行。 压缩完成后，数据存储将触发 compaction.done 事件。

您还可以使用 yourDatabase.persistence.setAutocompactionInterval(interval) 设置自动压缩，interval 以毫秒为单位（强制至少 5s），并停止自动压缩你的数据库.persistence.stopAutocompaction()。

请记住，压缩需要一点时间（不是太多：在典型的开发机器上 50k 记录需要 130 毫秒）并且在压缩时不会发生其他操作，因此大多数项目实际上不需要使用它。

假设数据库中所有损坏文档的总百分比仍然低于指定的 corruptAlertThreshold 选项值，Compaction 也会立即删除任何数据行已损坏的文档。

持久性与主要数据库的工作方式类似：压缩强制操作系统将数据物理刷新到磁盘，而附加到数据文件则不会（操作系统负责刷新数据）。 这保证了服务器崩溃永远不会导致数据完全丢失，同时保持性能。 可能发生的最坏情况是两次同步之间的崩溃，导致两次同步之间的所有数据丢失。 通常同步间隔为 30 秒，因此最多 30 秒的数据。 Antirez 关于 Redis 持久性的这篇文章 对此进行了更详细的解释，NeDB 正在非常接近于 appendfsync 选项设置为 no 的 Redis AOF 持久性。

Inserting documents

本机类型是 String、Number、Boolean、Date 和 null。 您也可以使用 数组和子文档（对象）。 如果一个字段是undefined，它不会被保存（这不同于 MongoDB 将 undefined 转换为 null，我觉得这有悖常理）。

如果文档不包含 _id 字段，NeDB 会自动为您生成一个（16 个字符的字母数字字符串）。 文档的 _id 一旦设置，就无法修改。

字段名称不能以“\$”开头或包含“.”。

var doc = {
  hello: 'world',
  n: 5,
  today: new Date(),
  nedbIsAwesome: true,
  notthere: null,
  notToBeSaved: undefined, // Will not be saved
  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
});

您还可以批量插入文档数组。 此操作是原子的，这意味着如果由于违反唯一约束而导致一次插入失败，则所有更改都将回滚。

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

// If there is a unique constraint on field 'a', this will fail
db.insert([{ a: 5 }, { a: 42 }, { a: 5 }], function (err) {
  // err is a 'uniqueViolated' error
  // The database was not modified
});

Finding documents

使用 find 查找与您查询匹配的多个文档，或使用 findOne 查找一个特定文档。 您可以根据字段相等性或使用比较运算符（$lt、$lte、$gt、$gte 选择文档代码>、<代码>$in、<代码>$nin、<代码>$ne）。 您还可以使用逻辑运算符 $or、$and、$not 和 $where。 请参阅下面的语法。

您可以通过两种方式使用正则表达式：在基本查询中代替字符串，或使用 $regex 运算符。

您可以使用游标 API（见下文）对结果进行排序和分页。

您可以使用标准投影来限制字段出现在结果中（见下文）。

Basic querying

基本查询手段是查找其字段与您指定的字段匹配的文档。 您可以使用正则表达式来匹配字符串。 您可以使用点表示法在嵌套文档、数组、子文档数组中导航，并匹配数组的特定元素。

// Let's say our datastore contains the following collection
// { _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 } ] } }

// Finding all planets in the solar system
db.find({ system: 'solar' }, function (err, docs) {
  // docs is an array containing documents Mars, Earth, Jupiter
  // If no document is found, docs is equal to []
});

// Finding all planets whose name contain the substring 'ar' using a regular expression
db.find({ planet: /ar/ }, function (err, docs) {
  // docs contains Mars and Earth
});

// Finding all inhabited planets in the solar system
db.find({ system: 'solar', inhabited: true }, function (err, docs) {
  // docs is an array containing document Earth only
});

// Use the dot-notation to match fields in subdocuments
db.find({ 'humans.genders': 2 }, function (err, docs) {
  // docs contains Earth
});

// Use the dot-notation to navigate arrays of subdocuments
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
});

// You can also deep-compare objects. Don't confuse this with dot-notation!
db.find({ humans: { genders: 2 } }, function (err, docs) {
  // docs is empty, because { genders: 2 } is not equal to { genders: 2, eyes: true }
});

// Find all documents in the collection
db.find({}, function (err, docs) {});

// The same rules apply when you want to only find one document
db.findOne({ _id: 'id1' }, function (err, doc) {
  // doc is the document Mars
  // If no document is found, doc is null
});

Operators ($lt, $lte, $gt, $gte, $in, $nin, $ne, $exists, \$regex)

语法是 { field: { $op: value } } 其中 $op 是任何比较运算符：

• $lt, $lte: less than, less than or equal
• $gt, $gte: greater than, greater than or equal
• $in: member of. value must be an array of values
• $ne, $nin: not equal, not a member of
• $exists: checks whether the document posses the property field. value should be true or false
• $regex: checks whether a string is matched by the regular expression. Contrary to MongoDB, the use of $options with $regex is not supported, because it doesn't give you more power than regex flags. Basic queries are more readable so only use the $regex operator when you need to use another operator with it (see example below)

// $lt, $lte, $gt and $gte work on numbers and strings
db.find({ 'humans.genders': { $gt: 5 } }, function (err, docs) {
  // docs contains Omicron Persei 8, whose humans have more than 5 genders (7).
});

// When used with strings, lexicographical order is used
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
});

Array fields

当文档中的字段是数组时，NeDB 首先尝试查看如果查询值是一个数组来进行精确匹配，那么是否有一个数组特定的比较函数（目前只有$size和$elemMatch）用过的。 如果不是，则查询被视为对每个元素的查询，如果至少有一个元素匹配，则存在匹配。

• $size: match on the size of the array
• $elemMatch: matches if at least one array element matches the query entirely

// Exact match
db.find({ satellites: ['Phobos', 'Deimos'] }, function (err, docs) {
  // docs contains Mars
});
db.find({ satellites: ['Deimos', 'Phobos'] }, function (err, docs) {
  // docs is empty
});

// Using an array-specific comparison function
// $elemMatch operator will provide match for a document, if an element from the array field satisfies all the conditions specified with the `$elemMatch` operator
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
});

// You can use inside #elemMatch query any known document query operator
db.find({ completeData: { planets: { $elemMatch: { name: 'Earth', number: { $gt: 2 } } } } }, function (err, docs) {
  // docs contains documents with id 5 (completeData)
});

// Note: you can't use nested comparison functions, e.g. { $size: { $lt: 5 } } will throw an error
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!)
});

Logical operators $or, $and, $not, $where

您可以使用逻辑运算符组合查询：

• For $or and $and, the syntax is { $op: [query1, query2, ...] }.
• For $not, the syntax is { $not: query }
• For $where, the syntax is { $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
});

Sorting and paginating

如果您没有指定回调到 find、findOne 或 count，Cursor< /code> 对象被返回。 您可以使用sort、skip 和limit 修改游标，然后使用exec(callback) 执行它。

// Let's say the database contains these 4 documents
// 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!

Projections

您可以为 find 和 findOne 提供可选的第二个参数，projections。 语法与 MongoDB 相同：{ a: 1, b: 1 } 仅返回 a 和 b 字段，{ a: 0, b: 0 } 省略这两个字段。 你不能同时使用这两种模式，除了 _id 默认情况下总是返回并且你可以选择忽略它。 您可以在嵌套文档上投影。

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

Counting documents

您可以使用 count 来计算文档数量。 它的语法与 find 相同。 例如：

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

Updating documents

db.update(query, update, options, callback) 会根据update规则更新所有匹配query的文档：

• query is the same kind of finding query you use with find and findOne
• update specifies how the documents should be modified. It is either a new document or a set of modifiers (you cannot use both together, it doesn't make sense!)
• A new document will replace the matched docs
• The modifiers create the fields they need to modify if they don't exist, and you can apply them to subdocs. Available field modifiers are $set to change a field's value, $unset to delete a field, $inc to increment a field's value and $min/$max to change field's value, only if provided value is less/greater than current value. To work on arrays, you have $push, $pop, $addToSet, $pull, and the special $each and $slice. See examples below for the syntax.
• options is an object with two possible parameters
• multi (defaults to false) which allows the modification of several documents if set to true
• upsert (defaults to false) if you want to insert a new document corresponding to the update rules if your query doesn't match anything. If your update is a simple object with no modifiers, it is the inserted document. In the other case, the query is stripped from all operator recursively, and the update is applied to it.
• returnUpdatedDocs (defaults to false, not MongoDB-compatible) if set to true and update is not an upsert, will return the array of documents matched by the find query and updated. Updated documents will be returned even if the update did not actually modify them.
• callback (optional) signature: (err, numAffected, affectedDocuments, upsert). Warning: the API was changed between v1.7.4 and v1.8. Please refer to the change log to see the change.
• For an upsert, affectedDocuments contains the inserted document and the upsert flag is set to true.
• For a standard update with returnUpdatedDocs flag set to false, affectedDocuments is not set.
• For a standard update with returnUpdatedDocs flag set to true and multi to false, affectedDocuments is the updated document.
• For a standard update with returnUpdatedDocs flag set to true and multi to true, affectedDocuments is the array of updated documents.

注意：您无法更改文档的_id。

// Let's use the same example collection as in the "finding document" part
// { _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 }

// Replace a document by another
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)
});

// Set an existing field's value
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'
});

// Setting the value of a non-existing field in a subdocument by using the dot-notation
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
  });
});

// Deleting a field
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
});

// Upserting a document
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
});

Removing documents

db.remove(query, options, callback) 将根据 options 删除所有匹配 query 的

• query is the same as the ones used for finding and updating
• options only one option for now: multi which allows the removal of multiple documents if set to true. Default is false
• callback is optional, signature: err, numRemoved

// Let's use the same example collection as in the "finding document" part
// { _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 }

// Remove one document from the collection
// options set to {} since the default for multi is false
db.remove({ _id: 'id2' }, {}, function (err, numRemoved) {
  // numRemoved = 1
});

// Remove multiple documents
db.remove({ system: 'solar' }, { multi: true }, function (err, numRemoved) {
  // numRemoved = 3
  // All planets from the solar system were removed
});

// Removing all documents with the 'match-all' query
db.remove({}, { multi: true }, function (err, numRemoved) {});

Indexing

文档 NeDB 支持索引。 它提供了非常好的速度提升，可用于在字段上强制执行唯一约束。 您可以索引任何字段，包括使用点表示法的嵌套文档中的字段。 目前，索引仅用于加速基本查询和使用 $in、$lt、$lte、$gt 的查询 和 $gte。 索引值不能是对象数组类型。

要创建索引，请使用 datastore.ensureIndex(options, cb)，其中回调是可选的，如果有错误（通常是违反的唯一约束），则传递错误。 ensureIndex 可以在您需要时调用，即使在插入一些数据之后也是如此，但最好在应用程序启动时调用它。 选项有：

• fieldName (required): name of the field to index. Use the dot notation to index a field in a nested document.
• unique (optional, defaults to false): enforce field uniqueness. Note that a unique index will raise an error if you try to index two documents for which the field is not defined.
• sparse (optional, defaults to false): don't index documents for which the field is not defined. Use this option along with "unique" if you want to accept multiple documents for which it is not defined.
• expireAfterSeconds (number of seconds, optional): if set, the created index is a TTL (time to live) index, that will automatically remove documents when the system date becomes larger than the date on the indexed field plus expireAfterSeconds. Documents where the indexed field is not specified or not a Date object are ignored

注意：_id 会自动使用唯一约束进行索引，无需对其调用 ensureIndex。

您可以使用 datastore.removeIndex(fieldName, cb) 删除之前创建的索引。

如果您的数据存储是持久的，您创建的索引将保存在数据文件中，当您第二次加载数据库时，它们会自动为您创建。 但是，无需删除任何 ensureIndex，如果在已经具有索引的数据库上调用它，则不会发生任何事情。

db.ensureIndex({ fieldName: 'somefield' }, function (err) {
  // If there was an error, err is not null
});

// Using a unique constraint with the index
db.ensureIndex({ fieldName: 'somefield', unique: true }, function (err) {});

// Using a sparse unique index
db.ensureIndex({ fieldName: 'somefield', unique: true, sparse: true }, function (err) {});

// Format of the error message when the unique constraint is not met
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' }
  });
});

// Remove index on field 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
});

注意 ensureIndex 函数同步创建索引，因此最好在应用程序启动时使用它。 它非常快，因此不会增加太多启动时间（包含 10,000 个文档的集合为 35 毫秒）。

Browser version

浏览器版本及其缩小版本位于 browser-version/out 目录中。 您只需要在您的 HTML 文件中引入 nedb.js 或 nedb.min.js 即可立即使用全局对象 Nedb，使用与服务器版本相同的 API：

<script src="nedb.min.js"></script>
<script>
  var db = new Nedb();   // Create an in-memory only datastore

  db.insert({ planet: 'Earth' }, function (err) {
   db.find({}, function (err, docs) {
     // docs contains the two planets Earth and Mars
   });
  });
</script>

如果指定 filename，数据库将持久化，并根据浏览器自动选择可用的最佳存储方法（IndexedDB、WebSQL 或 localStorage）。 在大多数情况下，这意味着可以存储大量数据，通常为数百 MB。 警告：存储系统在 v1.3 和 v1.4 之间发生了变化，并且不向后兼容！ 当您升级 NeDB 时，您的应用程序需要重新同步客户端。

NeDB 兼容所有主流浏览器：Chrome、Safari、Firefox、IE9+。 测试位于 browser-version/test 目录（文件 index.html 和 testPersistence.html）。

如果你 fork 和修改 nedb，你可以从源代码构建浏览器版本，构建脚本是 browser-version/build.js。

Performance

Speed

NeDB 无意取代 MongoDB 等大型数据库，因此其设计目的不是为了提高速度。 也就是说，它在预期的数据集上仍然非常快，特别是如果您使用索引。 在一个典型的、不太快的开发机器上，对于包含 10,000 个文档的集合，具有索引：

• Insert: 10,680 ops/s
• Find: 43,290 ops/s
• Update: 8,000 ops/s
• Remove: 11,750 ops/s

您可以通过执行 benchmarks 文件夹中的脚本来运行这些简单的基准测试。 使用 --help 标志运行它们以查看它们是如何工作的。

Memory footprint

整个数据库的副本保存在内存中。 这个就不多说了 预期的数据集类型（10,000 个 2KB 文档为 20MB）。

Use in other services

• connect-nedb-session is a session store for Connect and Express, backed by nedb
• If you mostly use NeDB for logging purposes and don't want the memory footprint of your application to grow too large, you can use NeDB Logger to insert documents in a NeDB-readable database
• If you've outgrown NeDB, switching to MongoDB won't be too hard as it is the same API. Use this utility to transfer the data from a NeDB database to a MongoDB collection
• An ODM for NeDB: Camo

Pull requests

如果您提交请求请求，谢谢！ 有一些规则要遵循，但要使其易于管理：

• The pull request should be atomic, i.e. contain only one feature. If it contains more, please submit multiple pull requests. Reviewing massive, 1000 loc+ pull requests is extremely hard.
• Likewise, if for one unique feature the pull request grows too large (more than 200 loc tests not included), please get in touch first.
• Please stick to the current coding style. It's important that the code uses a coherent style for readability.
• Do not include sylistic improvements ("housekeeping"). If you think one part deserves lots of housekeeping, use a separate pull request so as not to pollute the code.
• Don't forget tests for your new feature. Also don't forget to run the whole test suite before submitting to make sure you didn't introduce regressions.
• Do not build the browser version in your branch, I'll take care of it once the code is merged.
• Update the readme accordingly.
• Last but not least: keep in mind what NeDB's mindset is! The goal is not to be a replacement for MongoDB, but to have a pure JS database, easy to use, cross platform, fast and expressive enough for the target projects (small and self contained apps on server/desktop/browser/mobile). Sometimes it's better to shoot for simplicity than for API completeness with regards to MongoDB.

Bug reporting guidelines

如果您报告错误，谢谢！ 也就是说，为了使流程易于管理，请严格遵守以下准则。 我将无法处理那些没有的错误报告：

• Your bug report should be a self-containing gist complete with a package.json for any dependencies you need. I need to run through a simple git clone gist; npm install; node bugreport.js, nothing more.
• It should use assertions to showcase the expected vs actual behavior and be hysteresis-proof. It's quite simple in fact, see this example: https://gist.github.com/louischatriot/220cf6bd29c7de06a486
• Simplify as much as you can. Strip all your application-specific code. Most of the time you will see that there is no bug but an error in your code :)
• 50 lines max. If you need more, read the above point and rework your bug report. If you're really convinced you need more, please explain precisely in the issue.
• The code should be Javascript, not Coffeescript.

Bitcoins

你没有时间？ 您可以通过向此地址发送比特币来支持 NeDB：1dDZLnWpBbodPiN8sizzYrgaz5iahFyb1

License

请参阅许可证