PouchDB - 快速指南

---

PouchDB - 概述

本章简要介绍 PouchDB 及其功能和工作原理。

什么是 PouchDB？

PouchDB 是一个用 JavaScript 编写的开源浏览器内数据库 API。它是仿照Couch DB + 建模的。NoSQL 数据库。使用这个 API，我们可以构建离线和在线工作的应用程序。它内部使用WebSQL和IndexedDB来存储数据。

它是如何工作的？

在PouchDB中，当应用程序离线时，数据在浏览器中使用WebSQL和IndexedDB存储在本地。当应用程序重新上线时，它会与 CouchDB 和兼容服务器同步。

使用 PouchDB，您可以与本地和远程数据库无缝通信，而不会注意到任何差异。

PouchDB的特点

以下是 PouchDB 的功能 -

• 跨浏览器- PouchDB提供的API在每个环境中都相同，因此，我们可以在各种浏览器中运行PouchDB应用程序。

• 轻量级- PouchDB 是一个非常轻量级的 API，只需使用脚本标签即可轻松包含它。

• 易于学习- 如果您预先了解任何编程语言，那么学习 PouchDB 就很容易。

• 开源- PouchDB 是一个开源应用程序，可在 GitHub 上获取。

PouchDB的优点

以下是 PouchDB 的优点 -

• 由于 PouchDB 驻留在浏览器内部，因此不需要通过网络执行查询，这会导致查询执行速度更快。

• 您可以将数据与任何支持的服务器同步，这样您就可以在线和离线运行应用程序。

支持 PouchDB 的浏览器

以下是支持 PouchDB 的浏览器 -

• Firefox 29+（包括 Firefox OS 和 Android 版 Firefox）
• 铬30+
• 野生动物园 5+
• 互联网浏览器 10+
• 歌剧 21+
• 安卓4.0+
• iOS 7.1+
• Windows 手机 8+

PouchDB - 环境

本章介绍如何在系统中下载并安装 PouchDB。

安装 PouchDB

为了使用 PouchDB，您需要下载.js文件并将其包含在脚本中。以下是安装 PouchDB 的步骤。

步骤1

单击以下链接访问 PouchDB 网站的主页 -

https://PouchDB.com/

第2步

单击网页右上角的“下载”按钮，如上面的屏幕截图所示。这将在您的系统中下载PouchDB-5.3.0.min.js。

步骤3

将PouchDB-5.3.0.min.js复制并粘贴到您的工作目录，并将其包含在 JavaScript 中，如以下命令所示。

<script src = "PouchDB-5.3.0.min.js"></script>

使用 Node.js 安装 Pouch

您还可以将 PouchDB 安装为 Node.js 模块。以下是使用 Node.js 安装 PouchDB 的步骤。

步骤1

按照咖啡脚本教程的安装 Node.js 部分中给出的步骤安装 Node.js。

第2步

打开命令提示符并执行以下命令。这将在您的系统中安装 PouchDB 节点模块。

npm install --save PouchDB

下载 CouchDB

离线时，PouchDB 在本地存储数据并像应用程序一样工作。您可以通过连接兼容的服务器在线访问它。我们知道 PouchDB 可以连接到 CouchDB，所以我们也安装 CouchDB。以下是安装 CouchDB 的步骤。

步骤1

CouchDB 的官方网站是http://couchdb.apache.org。如果您点击给定的链接，您可以访问CouchDB官方网站的主页，如下图所示。

第2步

如果您点击下载按钮，将进入一个页面，其中提供了各种格式的 CouchDB 下载链接。下面的快照说明了同样的情况。

步骤3

选择 Windows 系统的下载链接，然后选择提供的镜像之一开始下载。

安装 CouchDB

Windows 可执行文件 setup-couchdb-1.6.1_R16B02.exe文件将下载到您的系统上。运行安装文件并继续安装。

在系统中成功安装 CouchDB 后，打开安装 CouchDB 的文件夹，转到 bin 文件夹，然后通过运行名为couchdb.bat的脚本文件启动服务器。

安装后，通过访问以下链接打开 CouchDB 的内置 Web 界面 - http://127.0.0.1:5984/。如果一切顺利，这将为您提供一个网页，其中将包含以下输出。

{                 
   "couchdb":"Welcome","uuid":"c8d48ac61bb497f4692b346e0f400d60",
   "version":"1. 6.1",
   "vendor": {
      "version":"1.6.1","name":"The Apache Software Foundation"
   } 
}

您可以使用以下 URL 与 CouchDB Web 界面进行交互 -

http://127.0.0.1:5984/_utils/

这显示了 Futon 的索引页面，它是 CouchDB 的 Web 界面。

PouchDB - 创建数据库

您可以使用 PouchDB 构造函数在 PouchDB 中创建数据库。

句法

以下是使用 PouchDB 构造函数的语法。为此，您需要将数据库的名称作为参数传递。

new PouchDB(Database_name)

例子

要使用Node在 PouchDB 中创建数据库，首先需要使用require()方法来引用 PouchDB 包，然后就可以创建数据库，如下例所示。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');
console.log ("Database created Successfully.");

将以上代码保存在名为Create_Database.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples>node Create_Database.js

这将在本地创建一个数据库（您可以看到当前目录中的文件夹），并显示以下消息。

Database created Successfully.

PouchDB - 数据库信息

您可以使用名为info()的方法获取有关数据库的基本信息

句法

以下是使用 PouchDB 的info()方法的语法。该方法接受回调函数。

db.info([callback])

例子

以下是使用info()方法检索数据库信息的示例。在这里，我们显示名为my_database的数据库的信息。如果出现错误，错误将显示在控制台上。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Database information
db.info(function(err, info) {
   if (err) {
      return console.log(err);
   } else {
      console.log(info);
   }
});

将以上代码保存在名为Database_info.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples>node Database_info.js

这将显示指定数据库的信息，如下所示。

{ 
   doc_count: 0,
   update_seq: 0,
   backend_adapter: 'LevelDOWN',
   db_name: 'my_database',
   auto_compaction: false,
   adapter: 'leveldb' 
}

远程数据库信息

以同样的方式，您可以获取远程保存在服务器上的数据库（CouchDB）的信息。为此，您需要传递 CouchDB 中所需数据库的路径，而不是数据库名称。

例子

以下是检索 CouchDB 服务器中保存的数据库信息的示例。此代码为您提供名为my_database的数据库的信息。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Database information
db.info(function(err, info) {
   if (err) {
      return console.log(err);
   } else {
      console.log(info);
   }
});

将以上代码保存在名为Database_ Remote_info.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples>node Database_Remote_info.js

这将显示指定数据库的信息，如下所示。

{ 
   db_name: 'my_database', 
   doc_count: 0, 
   doc_del_count: 0, 
   update_seq: 0, 
   purge_seq: 0, 
   compact_running: false, 
   disk_size: 79, 
   data_size: 0, 
   instance_start_time: '1458209191708486', 
   disk_format_version: 6, 
   committed_update_seq: 0, 
   host: 'http://localhost:5984/my_database/', 
   auto_compaction: false, 
   adapter: 'http' 
}

PouchDB - 删除数据库

您可以使用db.destroy()方法删除 PouchDB 中的数据库。

句法

以下是使用db.destroy()方法的语法。该方法接受回调函数作为参数。

db.destroy()

例子

以下是使用destroy()方法删除 PouchDB 中数据库的示例。在这里，我们将删除在前面的章节中创建的名为my_database的数据库。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//deleting database
db.destroy(function (err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log ("Database Deleted”);
   }
});

将以上代码保存在名为Delete_Database.js 的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Delete_Database.js

这将删除本地存储的名为my_database的数据库，并显示以下消息。

Database Deleted

删除远程数据库

以同样的方式，您可以删除远程存储在服务器上的数据库（CouchDB）。

为此，您需要在 CouchDB 中传递需要删除的数据库的路径，而不是数据库名称。

例子

假设CouchDB服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

以下是删除CouchDB 服务器中保存的名为my_database的数据库的示例。

//Requiring the package
var PouchDB = require('pouchdb');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//deleting database
db.destroy(function (err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Database Deleted");
   }
});

将以上代码保存在名为Remote_Database_Delete.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >Remote_Database_Delete.js

这将从 PouchDB 中删除指定的数据库，并显示以下消息。

Database Deleted

确认

执行上述程序后，如果再次访问该URL，您将得到以下屏幕截图。自从my_database被删除以来，您在这里只能观察到两个数据库。

PouchDB - 创建文档

您可以使用db.put()方法在 PouchDB 中创建文档。

句法

以下是使用 PouchDB 的 db.put() 方法的语法。您可以将要在 PouchDB 中创建的文档存储在变量中，并作为参数传递给此方法。此外，该方法还接受回调（可选）函数作为参数。

db.put(document, callback)

例子

以下是使用put()方法在 PouchDB 中创建文档的示例。我们创建的文档应该是 JSON 格式，一组由逗号 ( , ) 分隔并括在大括号 ( {} ) 内的键值对。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing the document
doc = {
   _id : '001',
   name: 'Raju',
   age : 23,
   designation : 'Designer'
   }
//Inserting Document
db.put(doc, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document created Successfully");
   }
});

将以上代码保存在名为Create_Document.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Create_Document.js

这将在名为my_database的 PouchDB 数据库中创建给定文档，该数据库存储在本地，并显示以下消息。

Document created Successfully

在远程数据库中插入文档

您还可以在远程存储在服务器上的数据库 (CouchDB) 中插入文档。

为此，您需要传递要在 CouchDB 中创建文档的数据库的路径，而不是数据库名称。

例子

假设CouchDB服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

现在，如果单击名为my_database的数据库，您将发现一个空数据库，如以下屏幕截图所示。

以下是在 CouchDB 服务器中保存的名为my_database的数据库中插入文档的示例。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Preparing the document
doc = {
   _id : '001',
   name: 'Raju',
   age : 23,
   designation : 'Designer'
   }
//Inserting Document
db.put(doc, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document created Successfully");
   }
});

将以上代码保存在名为Remote_Create_Document.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Create_Document.js

这将在名为my_database的 PouchDB 数据库中创建给定文档，该数据库存储在 CouchDB 中，并显示以下消息。

Document created Successfully

确认

执行完上述程序后，如果再次访问my_database ，可以观察到创建的文档，如下图所示。

PouchDB - 阅读文档

您可以使用db.get()方法读取/检索 PouchDB 中文档的内容。

句法

以下是使用 PouchDB 的db.get()方法的语法。此方法接受文档 ID和可选的回调函数。

db.get(document, callback)

例子

以下是使用get()方法读取 PouchDB 中文档内容的示例。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

将以上代码保存在名为Read_Document.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Read_Document.js

这将读取本地存储的名为my_database 的数据库中存在的给定文档的内容。控制台上显示以下消息。

{
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _id: '001',
   _rev: '1-ba7f6914ac80098e6f63d2bfb0391637'
}

从远程数据库读取文档

您还可以从远程存储在服务器 (CouchDB) 上的数据库读取文档。

为此，您需要传递 CouchDB 中数据库的路径（而不是数据库名称），其中包含要读取的文档。

例子

假设， CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

通过单击名为my_database的数据库，您可以看到以下屏幕截图。在这里，您可以观察到该数据库包含 id 为001的文档。

以下是读取 id 为“ 001 ”的文档内容的示例，该文档存在于名为my_database的数据库中，该数据库存储在 CouchDB 服务器中。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Reading the contents of a document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

将以上代码保存在名为Remote_Read_Document.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Read_Document.js

这将读取存储在 CouchDB 中名为my_database的数据库中存在的给定文档的内容。控制台上显示以下消息。

{ 
   _id: '001',
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   name: 'Raju',
   age: 23,
   designation: 'Designer' 
}

PouchDB - 更新文档

每当我们在 PouchDB 中创建文档时，都会生成一个新字段_rev，它被称为修订标记。_rev的值是一个唯一的随机数，每次我们对文档进行更改时，_rev 的值都会更改。

您可以使用(_rev)更新 PouchDB 中的现有文档。为此，首先检索我们要更新的文档的_rev值。现在，将要更新的内容与检索到的_rev值一起放入新文档中，最后使用put()方法将该文档插入到 PouchDB 中。

例子

假设我们在 PouchDB 中有一个 id 为001的文档，其中包含一个人的详细信息。为了更新此文档，我们应该知道其修订号。因此，要检索文档的内容，请使用以下代码。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

执行上述代码后，您将收到以下输出。

{
   _id: '001',
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   name: 'Raju',
   age: 23,
   designation: 'Designer' 
}

现在，使用_rev您可以将键“ age ”的值更新为 26，如以下代码所示。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing the document for update
doc = {
   age: 26,
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   }

//Inserting Document
db.put(doc);

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

将以上代码保存在名为Update_Document.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\Pouch_Examples>node Update_Document.js

这将更新本地存储的名为my_database 的数据库中存在的给定文档的内容。控制台上显示以下消息。

{ 
   name: 'Raju',
   age: 26,
   designation: 'Designer',
   _id: '001',
   _rev: '2-61b523ccdc4e41a8435bdffbb057a7a5' 
}

更新远程数据库中的文档

您还可以更新远程存储在服务器 (CouchDB) 上的数据库中的现有文档。

为此，您需要传递 CouchDB 中数据库的路径（而不是数据库名称），其中包含要更新的文档。

例子

假设CouchDB服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

通过单击名为my_database的数据库，您可以看到以下屏幕截图。在这里，您可以观察到该数据库包含 id 为001的文档。

以下是更新存储在 CouchDB 服务器中名为my_database 的数据库中存在的id 为“ 001 ”的文档的年龄的示例。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Preparing the document for update
doc = {
   age: 26,
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   }

//Inserting Document
db.put(doc);

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});   

将以上代码保存在名为Remote_Update_Document.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Update_Document.js

这将更新存储在 CouchDB 中名为my_database的数据库中存在的给定文档的内容。控制台上显示以下消息。

{
   _id: '001',
   _rev: '2-b9640bffbce582c94308905eed8bb545',
   name: 'Raju',
   age: 26,
   designation: 'Designer' 
}

PouchDB - 删除文档

您可以使用db.remove()方法从 PouchDB 中存在的数据库中删除文档。

句法

以下是使用 PouchDB 的db.remove()方法的语法。对于此方法，我们必须传递id和_rev来删除现有文档，如以下代码所示。该方法接受一个可选的回调函数。我们还可以传递完整的文档而不是 id 和 _rev。

db. get ( docId, docRev, [callback] )
or
db. get ( docId, docRev, [callback] )

例子

假设我们在 PouchDB 中有一个 id 为001的文档，其中包含一个人的详细信息。为了删除该文档及其ID，我们还应该拥有其_rev编号。因此，检索文档的内容，如以下代码所示。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

执行上述代码会产生以下输出。

{
   _id: '001',
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   name: 'Raju',
   age: 23,
   designation: 'Designer' 
}

现在，使用文档的_rev和 id，您可以使用remove()方法删除该文档，如以下代码所示。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Deleting an existing document
db.remove('001', '3-552920d1ca372986fad7b996ce365f5d', function(err) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document deleted successfully");
   }
});

将以上代码保存在名为Delete_Document.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Delete_Document.js

这将删除本地存储的名为my_database 的数据库中存在的给定文档的内容。将显示以下消息。

Document deleted successfully

从远程数据库删除文档

您还可以从远程存储在服务器 (CouchDB) 上的数据库中删除现有文档。

为此，您需要传递 CouchDB 中数据库的路径（而不是数据库名称），其中包含要读取的文档。

例子

假设CouchDB服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

通过单击名为my_database的数据库，您可以看到以下屏幕截图。在这里，您可以观察到数据库包含 id 为001的文档。

以下是删除CouchDB 服务器中名为my_database 的数据库中存在的id 为“ 001 ”的文档内容的示例。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Deleting an existing document
db.remove('001', '3-552920d1ca372986fad7b996ce365f5d', function(err) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document deleted successfully");
   }
});

将上述代码保存在名为Remote_Delete_Document.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Delete_Document.js

这将删除存储在 CouchDB 中名为my_database 的数据库中存在的给定文档。将显示以下消息。

Document deleted successfully

PouchDB - 创建批次

您可以使用db.bulkDocs()方法在 PouchDB 中创建文档数组（批量）。在创建文档时，如果我们不提供 _id 值，则使用此方法，PouchDB 会代表我们为批量的所有文档生成唯一的 id。

句法

以下是使用 PouchDB 的db.bulkDocs()方法的语法。您可以将要在 PouchDB 中创建的所有文档存储在一个数组中，并将其作为参数传递给此方法。除此之外，该方法还接受回调（可选）函数作为参数。

db.bulkDocs(docs, [options], [callback])

例子

以下是使用db.bulkDocs()方法在 PouchDB 中创建多个文档的示例。我们创建的文档应该是 JSON 格式，一组由逗号（ ,）分隔并括在大括号（{} ）内的键值对。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing the documents array
doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'}
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}
docs = [doc1, doc2, doc3]

//Inserting Documents
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Documents created Successfully");
   }
});

将以上代码保存在名为Create_Batch.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Create_Batch.js

这将在本地存储的名为my_database 的PouchDB 数据库中创建给定文档。将显示以下消息。

Documents created Successfully

在远程数据库中插入批次

您可以在远程存储在服务器 (CouchDB) 上的数据库中插入文档数组。

为此，您需要传递我们要在 CouchDB 中创建文档的数据库的路径，而不是数据库名称。

例子

假设CouchDB服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

以下是在名为my_database的数据库中插入文档数组的示例，该数据库保存在 CouchDB 服务器中。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Preparing the documents array

doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'}
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}

docs = [doc1, doc2, doc3]

//Inserting Documents
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Documents created Successfully");
   }
});

将以上代码保存在名为Remote_Create_Batch.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Create_Batch.js

这将在名为my_database的 PouchDB 数据库中创建给定文档，该数据库存储在 CouchDB 中。将显示以下消息。

Document created Successfully

确认

执行完上述程序后，如果再次访问my_database ，可以观察到创建的文档，如下图所示。

PouchDB - 批量获取

您可以使用allDocs()方法从 PouchDB 中的数据库读取/检索多个/批量文档。

句法

以下是使用 PouchDB 的db.allDocs()方法的语法。该方法接受一个可选的回调函数。

db.allDocs()

例子

以下是使用db.allDocs()方法检索本地存储的名为my_database的数据库中的所有文档的示例。此方法以对象的形式检索文档数组，以获取需要作为docs.rows调用的每个文档的内容。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving all the documents in PouchDB
db.allDocs(function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log (docs.rows);
   }
});

将以上代码保存在名为Read_All_Document.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Read_All_Document.js

这将读取本地存储的名为my_database 的数据库中存在的所有文档。控制台上显示以下消息。

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-9dc57f5faa7ea90eeec22eba8bfd05f5' } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-9bf80afcedb9f8b5b35567292affb254' } 
    },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-1204f108e41bf8baf867856d5da16c57' } 
   }
]

一般来说，如上面的结果所示，使用allDocs()方法你只能看到每个文档的_id、key和_rev字段。但是，要在结果中包含整个文档，您必须将可选参数include_docs设置为 true，如下所示。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log (docs.rows);
   }
});

执行上述代码将为您提供指定文档中完整文档的列表，如以下代码所示。

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-9dc57f5faa7ea90eeec22eba8bfd05f5' },
      doc: { 
         name: 'Ram',
         age: 23,
         Designation: 'Programmer',
         _id: '001',
         _rev: '1-9dc57f5faa7ea90eeec22eba8bfd05f5' 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-9bf80afcedb9f8b5b35567292affb254' },
      doc: { 
         name: 'Robert',
         age: 24,
         Designation: 'Programmer',
         _id: '002',
         _rev: '1-9bf80afcedb9f8b5b35567292affb254' 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-1204f108e41bf8baf867856d5da16c57' },
      doc: { 
         name: 'Rahim',
         age: 25,
         Designation: 'Programmer',
         _id: '003',
         _rev: '1-1204f108e41bf8baf867856d5da16c57' 
      } 
   }
]

从远程数据库读取批次

您还可以从远程存储在服务器 (CouchDB) 上的数据库中获取所有文档。

为此，您需要传递 CouchDB 中数据库的路径（而不是数据库名称），其中包含要读取的文档。

例子

假设CouchDB服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

以下是读取存储在 CouchDB 服务器中名为my_database 的数据库中存在的所有文档的示例。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

将以上代码保存在名为Remote_Read_AllDocument.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Read_AllDocument.js

这将读取存储在 CouchDB 中名为my_database 的数据库中存在的给定文档的内容，并显示在控制台上，如下所示。

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '3-552920d1ca372986fad7b996ce365f5d' },
      doc: { 
         _id: '001',
         _rev: '3-552920d1ca372986fad7b996ce365f5d',
         name: 'Raju',
         age: 23,
         designation: 'Designer' 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-9af15cb11054ebe03a7816bf6c5e4128' },
      doc: { 
         _id: '002',
         _rev: '1-9af15cb11054ebe03a7816bf6c5e4128',
         name: 'Robert',
         age: 24,
         Designation: 'Programmer' 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-3033b5a78e915c52fd37325d42eb3935' },
      doc: { 
         _id: '003',
         _rev: '1-3033b5a78e915c52fd37325d42eb3935',
         name: 'Rahim',
         age: 25,
         Designation: 'Programmer' 
      } 
   } 
]

PouchDB - 批量更新

您可以使用bulkDocs()方法一次更新PouchDB中的文档数组。为此，您需要创建一个文档数组，其中每个文档包含_id、_rev和要更新的值。

假设 PouchDB 本地存储的名为my_database的数据库包含 3 个文档，即 doc1、doc2、doc3，其内容如下。

doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'}
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}

假设我们必须将所有 3 个文档中的年龄值增加 2 年。为此，首先您需要获取_rev值。因此，请使用以下代码获取这些文档的内容。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true},function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

将上面的代码保存为bulk_fetch.js。执行时，上述程序会为您提供数据库中文档的 _id 和 _rev 值，如下所示。

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-1604b0c3ff69dc1e261265fd60808404' } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-b5e49db7e984841bf12a13e3ee548125' } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-a7b342786ecc707aa91f3b321a177b51' } 
   } 
]

现在，您可以使用各自的_id和_rev值更新文档，如下所示。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_databas');

//Preparing the document
docs = [{_id : '001', _rev: '1-1604b0c3ff69dc1e261265fd60808404', age : 25, },
      {_id : '002', _rev: '1-b5e49db7e984841bf12a13e3ee548125', age : 26, },
      {_id : '003', _rev: '1-a7b342786ecc707aa91f3b321a177b51', age : 27 }]

//Updating the documents in bulk
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Documents Updated Successfully");
   }
});

将以上代码保存在名为Update_All_Document.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Update_All_Document.js

这将更新本地存储的名为my_database 的数据库中存在的所有文档，并显示以下消息。

Documents Updated Successfully

现在，如果您通过在回调之前将{include_docs: true}作为参数添加到allDocs()函数来执行bulk_fetch.js程序，那么您将可以看到文档的值已更新，如下所示。

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '2-77f3a9974dd578d12f3f2a33aae64c8d' },
      doc: { 
         age: 25,
         _id: '001',
         _rev: '2-77f3a9974dd578d12f3f2a33aae64c8d' 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '2-43966007568ce9567c96422195fcfa0d' },
      doc: { 
         age: 26,
         _id: '002',
         _rev: '2-43966007568ce9567c96422195fcfa0d' 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '2-6c5349652527f4f39583ff14f23cd677' },
      doc: { 
         age: 27,
         _id: '003',
         _rev: '2-6c5349652527f4f39583ff14f23cd677' 
      } 
   } 
]

从远程数据库批量更新

您可以更新远程存储在服务器上的数据库 (CouchDB) 中的所有文档。

为此，您需要传递 CouchDB 中数据库的路径（而不是数据库名称），其中包含要读取的文档。

例子

假设CouchDB服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

假设我们选择名为my_database的数据库，您可以观察到它包含 3 个文档，如下面的屏幕截图所示。

现在，使用以下代码获取这些文档的内容。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

将上面的代码保存为remote_bulk_fetch.js。执行时，上面的程序会为您提供数据库中所有文档的内容，如下所示。

[ 
   { 
      id: '001', 
      key: '001', 
      value: { rev: '3-552920d1ca372986fad7b996ce365f5d' }, 
      doc: { 
         _id: '001', 
         _rev: '3-552920d1ca372986fad7b996ce365f5d', 
         name: 'Raju', 
         age: 23, 
         designation: 'Designer' 
      } 
   },
   { 
      id: '002', 
      key: '002', 
      value: { rev: '1-9af15cb11054ebe03a7816bf6c5e4128' }, 
      doc: { 
         _id: '002', 
         _rev: '1-9af15cb11054ebe03a7816bf6c5e4128', 
         name: 'Robert', 
         age: 24, 
         Designation: 'Programmer' 
      } 
   }, 
   { 
      id: '003', 
      key: '003', 
      value: { rev: '1-3033b5a78e915c52fd37325d42eb3935' }, 
      doc: { 
         _id: '003',
         _rev: '1-3033b5a78e915c52fd37325d42eb3935',
         name: 'Rahim', 
         age: 25, 
         Designation: 'Programmer' 
      } 
   } 
]

以下是更新CouchDB 服务器中名为my_database 的数据库中存在的所有文档的示例。

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object 
var db = new PouchDB('http://localhost:5984/my_database'); 

//Preparing the document 
docs = [{_id : '001', _rev: '3-552920d1ca372986fad7b996ce365f5d', age : 24, }, 
      {_id : '002', _rev: '1-9af15cb11054ebe03a7816bf6c5e4128', age : 26, }, 
      {_id : '003', _rev: '1-3033b5a78e915c52fd37325d42eb3935', age : 27}]

//Inserting Document 
db.bulkDocs(docs, function(err, response) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(+"Documents Updated Successfully"); 
   } 
});

将以上代码保存在名为Remote_Update_Document.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Update_Document.js

这将更新存储在 CouchDB 中名为my_database的数据库中存在的所有给定文档的内容，并显示以下消息。

Documents Updated Successfully

现在，如果您执行remote_bulk_fetch.js程序，您将可以看到文档的值已更新，如下所示。

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '4-6bc8d9c7a60fed2ed1667ec0740c1f39' },
      doc: { 
         _id: '001',
         _rev: '4-6bc8d9c7a60fed2ed1667ec0740c1f39',
         age: 25 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '2-1aa24ce77d96bb9d2a0675cdf1e113e0' },
      doc: { 
         _id: '002',
         _rev: '2-1aa24ce77d96bb9d2a0675cdf1e113e0',
         age: 26 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '2-fa113149ba618eda77f73072974a2bc1' },
      doc: { 
         _id: '003',
         _rev: '2-fa113149ba618eda77f73072974a2bc1',
         age: 27 
      } 
   } 
]

PouchDB - 删除批次

您可以使用bulkDocs()方法一次删除PouchDB中的文档数组。为此，您需要创建一个要删除的文档数组，其中每个文档应包含_id和_rev。除了这些之外，您还必须添加另一个键值对_deleted: true。

假设 PouchDB 本地存储的名为my_database的数据库包含 3 个文档，即 doc1、doc2、doc3，其内容如下。

doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'}
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}

并说，我们必须删除所有三个文档。然后，首先您需要获取它们的_rev值。因此，请使用以下代码获取这些文档的内容。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true},function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

将上面的代码保存为bulk_fetch.js。执行上述程序将为您提供数据库中文档的 _id 和 _rev 值，如下所示。

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-1604b0c3ff69dc1e261265fd60808404' } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-b5e49db7e984841bf12a13e3ee548125' } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-a7b342786ecc707aa91f3b321a177b51' } 
   } 
]

现在，您可以使用各自的_id和_rev值删除文档，如下所示。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing the document
docs = [{_id : '001', _rev: '2-77f3a9974dd578d12f3f2a33aae64c8d', _deleted : true },
      {_id : '002', _rev: '2-43966007568ce9567c96422195fcfa0d', _deleted : true }, 
      {_id : '003', _rev: '2-6c5349652527f4f39583ff14f23cd677',_deleted : true }]

//Deleting Documents
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log(response+"Documents deleted Successfully");
   }
});

将以上代码保存在名为Delete_All_Document.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Delete_All_Document.js

这将删除本地存储的名为my_database 的数据库中存在的所有文档，并显示以下消息。

Documents Deleted Successfully

现在，如果执行bulk_fetch.js程序，您可以在控制台上观察到一个空大括号，表明数据库为空，如下所示。

[]

从远程数据库批量删除

您可以更新远程存储在服务器上的数据库 (CouchDB) 中的所有文档。

为此，您需要传递 CouchDB 中数据库的路径（而不是数据库名称），其中包含要读取的文档。

例子

假设CouchDB服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

如果我们选择名为my_database的数据库，您可以观察到它包含 3 个文档，如下面的屏幕截图所示。

以下是删除存储在 CouchDB 服务器中名为my_database 的数据库中存在的所有文档的示例。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Preparing the document
docs = [{_id : '001', _rev: '4-6bc8d9c7a60fed2ed1667ec0740c1f39', _deleted : true },
      {_id : '002', _rev: '2-1aa24ce77d96bb9d2a0675cdf1e113e0', _deleted : true },
      {_id : '003', _rev: '2-fa113149ba618eda77f73072974a2bc1',_deleted : true }]

//Deleting Documents
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Documents deleted Successfully");
   }
});

将以上代码保存在名为Remote_delete_AllDocuments.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Delete_AllDocuments.js

这将删除存储在 CouchDB 中名为my_database 的数据库中存在的所有给定文档的内容，并显示以下消息。

Documents Deleted Successfully

PouchDB - 添加附件

您可以使用 PouchDB 中的putAttachment()方法将二进制对象附加到文档。

句法

以下是putAttachment()的语法。对于此方法，我们必须将文档 id、附件 id、MIME 类型以及附件一起传递。此方法还接受可选的回调函数。

db.putAttachment( docId, attachmentId, attachment, type, [callback] );

我们可以使用 blob 或 buffer 对象来准备附件，其中blob在使用浏览器时使用，而buffer在使用Node.js时使用，因为我们在 Node.js 中演示我们的程序，所以我们使用 buffer 对象来准备文档。

例子

以下是使用putAttachment()方法在 PouchDB 中名为my_database 的数据库中创建带附件的文档的示例。

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object var db = new PouchDB('my_database');

//Preparing the attachment 
var my_attachment = new Buffer(['Welcome to tutorialspoint'], {type: 'text/plain'});

//Adding attachment to a document 
db.putAttachment('001', 'att_1.txt', my_attachment, 'text/plain', function(err, res) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(res+"Attachment added successfully") 
   } 
});

将以上代码保存在名为Add_Attachment.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Add_Attachment.js

这将在存储在 PouchDB 中的名为my_database 的数据库中创建一个空文档，添加一个附件，并显示以下消息。

Attachment added successfully

您可以使用以下代码阅读文档来验证附件是否添加。

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object var db = new PouchDB('my_database');

//Reading the Document 
db.get('001',{attachments: true}, function(err, doc) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(doc); 
   } 
});

将上面的代码保存为read_doc.js并执行。执行该程序，可以看到该文件的以下内容。

{ 
   _attachments: { 
      att_1.txt: { 
         content_type: 'text/plain',
         digest: 'md5-k7iFrf4NoInN9jSQT9WfcQ==',
         data: 'AA==' 
      } 
   },
   _id: '001',
   _rev: '1-620fd5f41d3328fcbf9ce7504338a51d' 
}

将附件添加到现有文档

假设数据库中有一个名为my_database PouchDB 且 ID 为“ 002 ”的文档。您可以通过执行read_doc.js将 id 值更改为002来获取它的内容，如下所示。

{ 
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _id: '002',
   _rev: '1-05ca7b5f3f4762a9fb2d119cd34c8d40' 
}

现在，您可以使用其_rev值向此文档添加附件。

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object var db = new PouchDB('my_database');

//Adding attachment to existing document 
var my_attachment = new Buffer (['Welcome to tutorialspoint'], {type: 'text/plain'});

rev = '1-05ca7b5f3f4762a9fb2d119cd34c8d40'; 
db.putAttachment('002', 'att_1.txt', rev, my_attachment, 'text/plain', function(err, res) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log (res + "Attachment added successfully") 
   } 
});

将以上代码保存在名为Add_Attachment_to_doc.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Add_Attachment_to_doc.js

这将向指定文档添加一个附件，显示以下消息。

Attachment added successfully

如果将read_doc.js中的 id 值更改为002并执行它，您将得到以下输出。

{ 
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _attachments: { 
      att_1: { 
         content_type: 'text/plain',
         digest: 'md5-k7iFrf4NoInN9jSQT9WfcQ==',
         data: 'AA==' 
      } 
   },
   _id: '002',
   _rev: '2-3bb4891b954699bce28346723cc7a709' 
}

添加附件到远程文档

您甚至可以向远程存储在服务器 (CouchDB) 上的数据库中现有的文档添加附件。

为此，您需要传递 CouchDB 中数据库的路径（而不是数据库名称），其中包含要读取的文档。

例子

假设CouchDB服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

如果您选择名为my_database的数据库，您可以查看其内容，如下所示。

以下是向存储在 CouchDB 服务器中名为my_database 的数据库中存储的文档001添加附件的示例。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Adding attachment to existing document
var my_attachment = new Buffer (['Welcome to tutorialspoint'], {type: 'text/plain'});

rev = '1-36c34fdcf29a652876219065f9681602';
db.putAttachment('001', 'att_1.txt',rev, my_attachment, 'text/plain', function(err, res) {
   if (err) {
      return console.log(err);
   } else {
      console.log (res+ "Attachment added successfully")
   }
});

将以上代码保存在名为Remote_Add_Attachment.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Add_Attachment.js

这将向指定文档添加一个附件，显示以下消息。

Attachment added successfully

现在，如果您验证文档，您可以观察到添加到其中的附件，如以下屏幕截图所示。

PouchDB - 检索附件

您可以使用getAttachment()方法从 PouchDB 检索附件。此方法始终返回 blob 或缓冲区对象。

句法

以下是getAttachment()的语法。对于此方法，我们必须传递文档 id 和附件 id。此方法还接受可选的回调函数。

db.getAttachment( docId, attachmentId, [callback] );

例子

以下是使用getAttachment()方法检索存储在 PouchDB 中的文档附件的示例。使用此代码，我们尝试从文档001检索附件att_1.txt。

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving an attachment from a document
db.getAttachment('001', 'att_1.txt', function(err, blob_buffer) {
   if (err) {
      return console.log(err);
   } else {
      console.log(blob_buffer);
   }
});

将以上代码保存在名为Retrieve_Attachment.js的文件中。打开命令提示符并使用节点执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Retrieve_Attachment.js

这将检索文档的附件并显示在控制台上，如下所示。

<Buffer 00>

从远程文档检索附件

您还可以检索远程存储在服务器 (CouchDB) 上的数据库中现有文档的附件。

为此，您需要传递 CouchDB 中数据库的路径（而不是数据库名称），其中包含要读取的文档。

例子

假设CouchDB服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

如果您选择名为my_database的数据库，您可以查看其内容，如下所示。

假设该文档中有一个附件，如下所示。

以下是检索名为my_database 的数据库中存在的文档001的附件的示例，该数据库存储在 CouchDB 服务器中。

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the dat