javascript - Mongoose 中 "Schema"类的用途是什么？

Question

我开始学习 Mongoose，我有一个问题。

在文档中有很多地方我们使用新架构语法创建架构。例如:

var blogSchema = new Schema({
  title:  String,
  author: String,
  //other fields
});

然后使用它:

var Blog = mongoose.model('Blog', blogSchema);

但是在Mongoose's main page上有一个没有它的例子。我们只是将一个对象作为 mongoose.model 的第二个参数:

var Cat = mongoose.model('Cat', { name: String });

Schema 类的用途是什么？这两种方法有什么区别？

Answer 1

您想在其他地方重用该架构吗？您是否还意识到抽象嵌入语句会导致更清晰的代码？

主要区别是在您想要实际执行此操作的地方重用。第二个区别是单独的声明通常更容易阅读和理解。

这实际上更像是一个“编码风格”问题，因此为了尝试使其远离“表达和意见”，我主要指出了“重用”点。

另一个需要考虑的因素是，所有这些东西实际上只是对象构造函数，这并不意味着您需要将其用作“硬编码”方法。考虑从“配置文件”加载所有架构和模型信息，例如:

作为配置文件:

{

  "Schema": {

    "ownerSchema": {
      "name": { "type": "String" },
      "email": { "type": "String" },
      "accounts": [{ "type": "ObjectId", "ref": "Account" }]
    },

    "transactionSchema": {
      "account": { "type": "Number" },
      "added": { "type": "Date" }
    },

    "recentBucketSchema": {
      "_id": { "type": "ObjectId", "ref": "AccountBucket" },
      "day": { "type": "Date" }
    },

    "accountSchema": {
      "owner": { "type": "ObjectId", "ref": "Owner" },
      "balance": { "type": "Number", "default": 0 },
      "recent": [{ "schema": "recentBucketSchema" }]
    },

    "accountBucketSchema": {
      "day": { "type": "Date" },
      "account": { "type": "ObjectId", "ref": "Account" },
      "owner": { "type": "ObjectId", "ref": "Owner" },
      "balance": { "type": "Number", "default": 0 },
      "transactions": [{ "schema": "transactionSchema" }]
    }

  },

  "Models": {
    "Owner": { "schema": "ownerSchema" },
    "Account": { "schema": "accountSchema" },
    "AccountBucket": { "schema": "accountBucketSchema" }
  }

}

作为处理者:

var async = require('async'),
    fs = require('fs'),
    mongoose = require('mongoose'),
    Schema = mongoose.Schema;


function ReturnType(type) {
  switch(type) {
    case "String":
      return String;
    case "Number":
      return Number;
    case "Date":
      return Date;
    case "ObjectId":
      return Schema.Types.ObjectId;
  }
}

function ParseSchema(schema,data) {
  for ( k in schema ) {
    var outerType = Object.prototype.toString.call( schema[k] );
    if ( outerType !== "[object Array]" ) {
      schema[k].type = ReturnType(schema[k].type);
    } else {
      if ( schema[k][0].hasOwnProperty("schema") ) {
        schema[k][0] = ParseSchema(data.Schema[schema[k][0].schema],data)
      } else {
        schema[k][0].type = ReturnType(schema[k][0].type);
      }
    }
  }
  return new Schema( schema );
}

async.waterfall(
  [
    function(callback) {
      var file = __dirname + '/sample.json';
      fs.readFile(file, 'utf8', function(err,data) {
        if (err)
          callback(err);

        callback(err,JSON.parse(data));

      });
    },

    function(data,callback) {
      async.each( Object.keys( data.Models ), function(modelName,callback) {
        var currentSchema = data.Schema[data.Models[modelName].schema];

        currentSchema = ParseSchema(currentSchema,data);
        mongoose.model( modelName, currentSchema );
        callback();

      },function(err) {
        callback();
      });
    }
  ],
  function(err) {
    if (err)
      throw err;

  }
);

只是一个基本示例，但一般分离有一个明确的原因，因为您可以实际使用它。

因此，如果您的问题确实是“为什么有两种方法可以做到这一点？”，那么我可以说，实际上有很多方法可以做到这一点，而不仅仅是两种。框架和库不应该“将你锁定”在特定的做事方式上。它们应该可以以最适合您的方式免费使用。