模式

模式构造函数。

示例

const child = new Schema({ name: String });
const schema = new Schema({ name: String, age: Number, children: [child] });
const Tree = mongoose.model('Tree', schema);

// setting schema options
new Schema({ name: String }, { id: false, autoIndex: false })

选项

• autoIndex: bool - 默认值为 null（这意味着使用连接的 autoIndex 选项）
• autoCreate: bool - 默认值为 null（这意味着使用连接的 autoCreate 选项）
• bufferCommands: bool - 默认值为 true
• bufferTimeoutMS: number - 默认值为 10000（10 秒）。如果启用了 bufferCommands，Mongoose 将等待连接重新建立的时间，然后才会出错。
• capped: bool | number | object - 默认值为 false
• collection: string - 无默认值
• discriminatorKey: string - 默认值为 __t
• id: bool - 默认值为 true
• _id: bool - 默认值为 true
• minimize: bool - 控制 document#toObject 手动调用时的行为 - 默认值为 true
• read: string
• readConcern: object - 默认值为 null，用于设置所有查询的默认 读取关注度。
• writeConcern: object - 默认值为 null，用于覆盖 MongoDB 服务器的默认写入关注度设置
• shardKey: object - 默认值为 null
• strict: bool - 默认值为 true
• strictQuery: bool - 默认值为 false
• toJSON - object - 无默认值
• toObject - object - 无默认值
• typeKey - string - 默认值为 'type'
• validateBeforeSave - bool - 默认值为 true
• validateModifiedOnly - bool - 默认值为 false
• versionKey: string or object - 默认值为 "__v"
• optimisticConcurrency: bool - 默认值为 false。设置为 true 以启用 乐观并发。
• collation: object - 默认值为 null（这意味着不使用任何排序规则）
• timeseries: object - 默认值为 null（这意味着此模式的集合不会是时间序列集合）
• selectPopulatedPaths: boolean - 默认值为 true
• skipVersioning: object - 要从版本控制中排除的路径
• timestamps: object or boolean - 默认值为 false。如果为 true，Mongoose 会在您的模式中添加 createdAt 和 updatedAt 属性，并为您管理这些属性。
• pluginTags: 字符串数组 - 默认值为 undefined。如果设置并使用 tags 选项调用插件，则该插件将仅应用于具有匹配标签的模式。
• virtuals: object - 要定义的虚拟属性，是 .virtual 的别名
• [collectionOptions]: 将选项传递给 createCollection() 的对象，当调用 Model.createCollection() 或将 autoCreate 设置为 true 时。

嵌套模式的选项

• excludeIndexes: bool - 默认值为 false。如果为 true，则跳过在此模式的路径上构建索引。

注意

嵌套模式时（上面示例中的 children），请始终先声明子模式，然后将其传递给其父模式。

各种内置 Mongoose 模式类型。

示例

const mongoose = require('mongoose');
const ObjectId = mongoose.Schema.Types.ObjectId;

类型

• String
• Number
• Boolean | Bool
• Array
• Buffer
• Date
• ObjectId | Oid
• Mixed
• UUID
• BigInt

使用此暴露的 Mixed 模式类型访问方式，我们可以在模式中使用它们。

const Mixed = mongoose.Schema.Types.Mixed;
new mongoose.Schema({ _user: Mixed })

允许的索引类型

将键路径/模式类型对添加到此模式。

示例

const ToySchema = new Schema();
ToySchema.add({ name: 'string', color: 'string', price: 'number' });

const TurboManSchema = new Schema();
// You can also `add()` another schema and copy over all paths, virtuals,
// getters, setters, indexes, methods, and statics.
TurboManSchema.add(ToySchema).add({ year: Number });

为 path 添加别名。这意味着获取或设置 alias 等效于获取或设置 path。

示例

const toySchema = new Schema({ n: String });

// Make 'name' an alias for 'n'
toySchema.alias('n', 'name');

const Toy = mongoose.model('Toy', toySchema);
const turboMan = new Toy({ n: 'Turbo Man' });

turboMan.name; // 'Turbo Man'
turboMan.n; // 'Turbo Man'

turboMan.name = 'Turbo Man Action Figure';
turboMan.n; // 'Turbo Man Action Figure'

await turboMan.save(); // Saves { _id: ..., n: 'Turbo Man Action Figure' }

子模式数组（来自文档数组和单个嵌套子文档）及其相应的已编译模型。数组的每个元素都是一个包含 2 个属性的对象：schema 和 model。

此属性通常只对插件作者和高级用户有用。您根本不需要与该属性交互即可使用 mongoose。

从该模式中删除所有索引。

clearIndexes 仅从您的模式对象中删除索引。不会影响 MongoDB 中的索引。

示例

const ToySchema = new Schema({ name: String, color: String, price: Number });
ToySchema.index({ name: 1 });
ToySchema.index({ color: 1 });

// Remove all indexes on this schema
ToySchema.clearIndexes();

ToySchema.indexes(); // []

返回模式的深层副本

示例

const schema = new Schema({ name: String });
const clone = schema.clone();
clone === schema; // false
clone.path('name'); // SchemaString { ... }

通过对现有模式应用鉴别器来继承模式。

示例

const eventSchema = new mongoose.Schema({ timestamp: Date }, { discriminatorKey: 'kind' });

const clickedEventSchema = new mongoose.Schema({ element: String }, { discriminatorKey: 'kind' });
const ClickedModel = eventSchema.discriminator('clicked', clickedEventSchema);

const Event = mongoose.model('Event', eventSchema);

Event.discriminators['clicked']; // Model { clicked }

const doc = await Event.create({ kind: 'clicked', element: '#hero' });
doc.element; // '#hero'
doc instanceof ClickedModel; // true

类似于 Array#forEach 迭代模式路径。

回调将传递路径名和模式类型实例。

示例

const userSchema = new Schema({ name: String, registeredAt: Date });
userSchema.eachPath((pathname, schematype) => {
  // Prints twice:
  // name SchemaString { ... }
  // registeredAt SchemaDate { ... }
  console.log(pathname, schematype);
});

获取模式选项。

示例

schema.get('strict'); // true
schema.set('strict', false);
schema.get('strict'); // false

为此模式定义索引（最可能是复合索引）。

示例

schema.index({ first: 1, last: -1 })

返回该模式声明的索引列表，通过 schema.index() 或通过路径选项中的 index: true。索引表示为数组 [spec, options]。

示例

const userSchema = new Schema({
  email: { type: String, required: true, unique: true },
  registeredAt: { type: Date, index: true }
});

// [ [ { email: 1 }, { unique: true, background: true } ],
//   [ { registeredAt: 1 }, { background: true } ] ]
userSchema.indexes();

插件 可以使用此函数的返回值修改模式的索引。例如，以下插件默认情况下会将每个索引设为唯一。

function myPlugin(schema) {
  for (const index of schema.indexes()) {
    if (index[1].unique === undefined) {
      index[1].unique = true;
    }
  }
}

将 ES6 类加载到模式中。映射 setter + getter、静态方法 和 实例方法 到模式 虚拟属性、静态属性 和 方法。

示例

const md5 = require('md5');
const userSchema = new Schema({ email: String });
class UserClass {
  // `gravatarImage` becomes a virtual
  get gravatarImage() {
    const hash = md5(this.email.toLowerCase());
    return `https://www.gravatar.com/avatar/${hash}`;
  }

  // `getProfileUrl()` becomes a document method
  getProfileUrl() {
    return `https://mysite.com/${this.email}`;
  }

  // `findByEmail()` becomes a static
  static findByEmail(email) {
    return this.findOne({ email });
  }
}

// `schema` will now have a `gravatarImage` virtual, a `getProfileUrl()` method,
// and a `findByEmail()` static
userSchema.loadClass(UserClass);

向从使用此模式编译的模型构造的文档添加实例方法。

示例

const schema = kittySchema = new Schema(..);

schema.method('meow', function () {
  console.log('meeeeeoooooooooooow');
})

const Kitty = mongoose.model('Kitty', schema);

const fizz = new Kitty;
fizz.meow(); // meeeeeooooooooooooow

如果将名称/fn 对的哈希作为唯一参数传递，则每个名称/fn 对都将作为方法添加。

schema.method({
    purr: function () {}
  , scratch: function () {}
});

// later
const fizz = new Kitty;
fizz.purr();
fizz.scratch();

注意：Schema.method() 将实例方法添加到 Schema.methods 对象。您也可以直接将实例方法添加到 Schema.methods 对象，如 指南 中所示

传递给模式构造函数的原始对象

示例

const schema = new Schema({ a: String }).add({ b: String });
schema.obj; // { a: String }

返回一个新的模式，该模式具有原始模式中的 paths，但省略了省略的路径。

此方法类似于 Mongoose 模式 Lodash 的 omit() 函数。

示例

const schema = Schema({ name: String, age: Number });
// Creates a new schema omitting the `age` path
const newSchema = schema.omit(['age']);

newSchema.path('name'); // SchemaString { ... }
newSchema.path('age'); // undefined

获取/设置模式路径。

设置路径（如果元数为 2），获取路径（如果元数为 1）

示例

schema.path('name') // returns a SchemaType
schema.path('name', Number) // changes the schemaType of `name` to Number

返回此模式的 path 的 pathType。

给定一个路径，返回它是否是真实、虚拟、嵌套或临时/未定义的路径。

示例

const s = new Schema({ name: String, nested: { foo: String } });
s.virtual('foo').get(() => 42);
s.pathType('name'); // "real"
s.pathType('nested'); // "nested"
s.pathType('foo'); // "virtual"
s.pathType('fail'); // "adhocOrUndefined"

在此模式上定义的路径。键是此模式中的顶层路径，值是 SchemaType 类的实例。

示例

const schema = new Schema({ name: String }, { _id: false });
schema.paths; // { name: SchemaString { ... } }

schema.add({ age: Number });
schema.paths; // { name: SchemaString { ... }, age: SchemaNumber { ... } }

返回一个新的模式，该模式具有从该模式中选择的 paths。

此方法类似于 Mongoose 模式 Lodash 的 pick() 函数。

示例

const schema = Schema({ name: String, age: Number });
// Creates a new schema with the same `name` path as `schema`,
// but no `age` path.
const newSchema = schema.pick(['name']);

newSchema.path('name'); // SchemaString { ... }
newSchema.path('age'); // undefined

为该模式注册一个插件。

示例

const s = new Schema({ name: String });
s.plugin(schema => console.log(schema.path('name').path));
mongoose.model('Test', s); // Prints 'name'

或者使用选项

const s = new Schema({ name: String });
s.plugin((schema, opts) => console.log(opts.text, schema.path('name').path), { text: "Schema Path Name:" });
mongoose.model('Test', s); // Prints 'Schema Path Name: name'

为文档定义一个后置钩子

const schema = new Schema(..);
schema.post('save', function (doc) {
  console.log('this fired after a document was saved');
});

schema.post('find', function(docs) {
  console.log('this fired after you ran a find query');
});

schema.post(/Many$/, function(res) {
  console.log('this fired after you ran `updateMany()` or `deleteMany()`');
});

const Model = mongoose.model('Model', schema);

const m = new Model(..);
m.save(function(err) {
  console.log('this fires after the `post` hook');
});

m.find(function(err, docs) {
  console.log('this fires after the post find hook');
});

为模型定义一个预置钩子。

示例

const toySchema = new Schema({ name: String, created: Date });

toySchema.pre('save', function(next) {
  if (!this.created) this.created = new Date;
  next();
});

toySchema.pre('validate', function(next) {
  if (this.name !== 'Woody') this.name = 'Woody';
  next();
});

// Equivalent to calling `pre()` on `find`, `findOne`, `findOneAndUpdate`.
toySchema.pre(/^find/, function(next) {
  console.log(this.getFilter());
});

// Equivalent to calling `pre()` on `updateOne`, `findOneAndUpdate`.
toySchema.pre(['updateOne', 'findOneAndUpdate'], function(next) {
  console.log(this.getFilter());
});

toySchema.pre('deleteOne', function() {
  // Runs when you call `Toy.deleteOne()`
});

toySchema.pre('deleteOne', { document: true }, function() {
  // Runs when you call `doc.deleteOne()`
});

将方法调用添加到队列。

示例

schema.methods.print = function() { console.log(this); };
schema.queue('print', []); // Print the doc every one is instantiated

const Model = mongoose.model('Test', schema);
new Model({ name: 'test' }); // Prints '{"_id": ..., "name": "test" }'

删除给定的 path（或 [paths]）。

示例

const schema = new Schema({ name: String, age: Number });
schema.remove('name');
schema.path('name'); // Undefined
schema.path('age'); // SchemaNumber { ... }

或作为数组

schema.remove(['name', 'age']);
schema.path('name'); // Undefined
schema.path('age'); // Undefined

按名称或索引规范删除索引。

removeIndex 仅从模式对象中删除索引。不会影响 MongoDB 中的索引。

示例

const ToySchema = new Schema({ name: String, color: String, price: Number });

// Add a new index on { name, color }
ToySchema.index({ name: 1, color: 1 });

// Remove index on { name, color }
// Keep in mind that order matters! `removeIndex({ color: 1, name: 1 })` won't remove the index
ToySchema.removeIndex({ name: 1, color: 1 });

// Add an index with a custom name
ToySchema.index({ color: 1 }, { name: 'my custom index name' });
// Remove index by name
ToySchema.removeIndex('my custom index name');

从模式中删除给定的虚拟或虚拟。

返回一个由该模式要求的路径字符串数组。

示例

const s = new Schema({
  name: { type: String, required: true },
  age: { type: String, required: true },
  notes: String
});
s.requiredPaths(); // [ 'age', 'name' ]

添加一个 Atlas 搜索索引，Mongoose 将使用 Model.createSearchIndex() 创建。此函数仅在连接到 MongoDB Atlas 时有效。

示例

const ToySchema = new Schema({ name: String, color: String, price: Number });
ToySchema.searchIndex({ name: 'test', definition: { mappings: { dynamic: true } } });

设置模式选项。

示例

schema.set('strict'); // 'true' by default
schema.set('strict', false); // Sets 'strict' to false
schema.set('strict'); // 'false'

向从该模式编译的模型添加静态“类”方法。

示例

const schema = new Schema(..);
// Equivalent to `schema.statics.findByName = function(name) {}`;
schema.static('findByName', function(name) {
  return this.find({ name: name });
});

const Drink = mongoose.model('Drink', schema);
await Drink.findByName('LaCroix');

如果将名称/fn 对的哈希作为唯一参数传递，则每个名称/fn 对都将作为方法添加。

schema.static({
    findByName: function () {..}
  , findByCost: function () {..}
});

const Drink = mongoose.model('Drink', schema);
await Drink.findByName('LaCroix');
await Drink.findByCost(3);

如果将名称/fn 对的哈希作为唯一参数传递，则每个名称/fn 对将作为 statics 添加。

使用给定名称创建一个虚拟类型。

返回具有给定 name 的虚拟类型。

包含在此模式上定义的所有虚拟的对象。对象的键是虚拟路径，值是 VirtualType 的实例。

此属性通常只对插件作者和高级用户有用。您根本不需要与该属性交互即可使用 mongoose。

示例

const schema = new Schema({});
schema.virtual('answer').get(() => 42);

console.log(schema.virtuals); // { answer: VirtualType { path: 'answer', ... } }
console.log(schema.virtuals['answer'].getters[0].call()); // 42

保留的文档键。

此对象中的键是在模式声明中发出警告的名称，因为它们有可能破坏 Mongoose/ Mongoose 插件的功能。如果使用 new Schema() 创建一个具有这些属性名称之一的模式，Mongoose 将记录一个警告。

• _posts
• _pres
• collection
• emit
• errors
• get
• init
• isModified
• isNew
• listeners
• modelName
• on
• once
• populated
• prototype
• remove
• removeListener
• save
• schema
• toObject
• validate

注意： 允许将这些术语用作方法名称，但要自担风险，因为它们可能是您正在覆盖的现有 mongoose 文档方法。

 const schema = new Schema(..);
 schema.methods.init = function () {} // potentially breaking