验证 - 图1mongoose

验证 - 图2mongoose

[

验证 ](#验证)

如果你要使用验证，请注意一下几点：

  • 验证定义于 SchemaType
  • 验证是一个中间件。它默认作为 pre('save')` 钩子注册在 schema 上
  • 你可以使用 doc.validate(callback) 或 doc.validateSync() 手动验证
  • 验证器不对未定义的值进行验证，唯一例外是 required 验证器
  • 验证是异步递归的。当你调用 Model#save，子文档验证也会执行，出错的话 Model#save 回调会接收错误
  • 验证是可定制的 
  2.     var schema = new Schema({
  3.       name: {
  4.         type: String,
  5.         required: true
  6.       }
  7.     });
  8.     var Cat = db.model('Cat', schema);
  10.     // This cat has no name :(
  11.     var cat = new Cat();
  12.     cat.save(function(error) {
  13.       assert.equal(error.errors['name'].message,
  14.         'Path `name` is required.');
  16.       error = cat.validateSync();
  17.       assert.equal(error.errors['name'].message,
  18.         'Path `name` is required.');
  19.     });

[

内建 Validators ](#内建-validators)

Mongoose 有一些内建验证器。

上面的链接提供了使用和错误处理相关的详细信息

  2.     var breakfastSchema = new Schema({
  3.       eggs: {
  4.         type: Number,
  5.         min: [6, 'Too few eggs'],
  6.         max: 12
  7.       },
  8.       bacon: {
  9.         type: Number,
  10.         required: [true, 'Why no bacon?']
  11.       },
  12.       drink: {
  13.         type: String,
  14.         enum: ['Coffee', 'Tea'],
  15.         required: function() {
  16.           return this.bacon > 3;
  17.         }
  18.       }
  19.     });
  20.     var Breakfast = db.model('Breakfast', breakfastSchema);
  22.     var badBreakfast = new Breakfast({
  23.       eggs: 2,
  24.       bacon: 0,
  25.       drink: 'Milk'
  26.     });
  27.     var error = badBreakfast.validateSync();
  28.     assert.equal(error.errors['eggs'].message,
  29.       'Too few eggs');
  30.     assert.ok(!error.errors['bacon']);
  31.     assert.equal(error.errors['drink'].message,
  32.       '`Milk` is not a valid enum value for path `drink`.');
  34.     badBreakfast.bacon = 5;
  35.     badBreakfast.drink = null;
  37.     error = badBreakfast.validateSync();
  38.     assert.equal(error.errors['drink'].message, 'Path `drink` is required.');
  40.     badBreakfast.bacon = null;
  41.     error = badBreakfast.validateSync();
  42.     assert.equal(error.errors['bacon'].message, 'Why no bacon?');

[

unique 不是验证器 ](#unique-不是验证器)

初学者常见的 unique 选项 不是验证器。这是构建 MongoDB unique indexes 的辅助函数。 详见 FAQ。

  2.     var uniqueUsernameSchema = new Schema({
  3.       username: {
  4.         type: String,
  5.         unique: true
  6.       }
  7.     });
  8.     var U1 = db.model('U1', uniqueUsernameSchema);
  9.     var U2 = db.model('U2', uniqueUsernameSchema);
  11.     var dup = [{ username: 'Val' }, { username: 'Val' }];
  12.     U1.create(dup, function(error) {
  13.       // Race condition! This may save successfully, depending on whether
  14.       // MongoDB built the index before writing the 2 docs.
  15.     });
  17.     // Need to wait for the index to finish building before saving,
  18.     // otherwise unique constraints may be violated.
  19.     U2.once('index', function(error) {
  20.       assert.ifError(error);
  21.       U2.create(dup, function(error) {
  22.         // Will error, but will *not* be a mongoose validation error, it will be
  23.         // a duplicate key error.
  24.         assert.ok(error);
  25.         assert.ok(!error.errors);
  26.         assert.ok(error.message.indexOf('duplicate key error') !== -1);
  27.       });
  28.     });
  30.     // There's also a promise-based equivalent to the event emitter API.
  31.     // The `init()` function is idempotent and returns a promise that
  32.     // will resolve once indexes are done building;
  33.     U2.init().then(function() {
  34.       U2.create(dup, function(error) {
  35.         // Will error, but will *not* be a mongoose validation error, it will be
  36.         // a duplicate key error.
  37.         assert.ok(error);
  38.         assert.ok(!error.errors);
  39.         assert.ok(error.message.indexOf('duplicate key error') !== -1);
  40.       });
  41.     });

[

自定义验证器 ](#自定义验证器)

如果内建检验器不够用了，你可以定义满足自己需要的检验器

自定义检验器通过传入一个检验函数来定义，更多细节请看 SchemaType#validate() API 文档。

  2.     var userSchema = new Schema({
  3.       phone: {
  4.         type: String,
  5.         validate: {
  6.           validator: function(v) {
  7.             return /\d{3}-\d{3}-\d{4}/.test(v);
  8.           },
  9.           message: '{VALUE} is not a valid phone number!'
  10.         },
  11.         required: [true, 'User phone number required']
  12.       }
  13.     });
  15.     var User = db.model('user', userSchema);
  16.     var user = new User();
  17.     var error;
  19.     user.phone = '555.0123';
  20.     error = user.validateSync();
  21.     assert.equal(error.errors['phone'].message,
  22.       '555.0123 is not a valid phone number!');
  24.     user.phone = '';
  25.     error = user.validateSync();
  26.     assert.equal(error.errors['phone'].message,
  27.       'User phone number required');
  29.     user.phone = '201-555-0123';
  30.     // Validation succeeds! Phone number is defined
  31.     // and fits `DDD-DDD-DDDD`
  32.     error = user.validateSync();
  33.     assert.equal(error, null);

[

异步自定义验证器 ](#异步自定义验证器)

自定义检验器可以是异步的。如果检验函数 返回 promise (像 async 函数)， mongoose 将会等待该 promise 完成。 如果你更喜欢使用回调函数，设置 isAsync 选项， mongoose 会将回调函数作为验证函数的第二个参数。

  2.     var userSchema = new Schema({
  3.       name: {
  4.         type: String,
  5.         // You can also make a validator async by returning a promise. If you
  6.         // return a promise, do **not** specify the `isAsync` option.
  7.         validate: function(v) {
  8.           return new Promise(function(resolve, reject) {
  9.             setTimeout(function() {
  10.               resolve(false);
  11.             }, 5);
  12.           });
  13.         }
  14.       },
  15.       phone: {
  16.         type: String,
  17.         validate: {
  18.           isAsync: true,
  19.           validator: function(v, cb) {
  20.             setTimeout(function() {
  21.               var phoneRegex = /\d{3}-\d{3}-\d{4}/;
  22.               var msg = v + ' is not a valid phone number!';
  23.               // 第一个参数是布尔值，代表验证结果
  24.               // 第二个参数是报错信息
  25.               cb(phoneRegex.test(v), msg);
  26.             }, 5);
  27.           },
  28.           // 默认报错信息会被 `cb()` 第二个参数覆盖
  29.           message: 'Default error message'
  30.         },
  31.         required: [true, 'User phone number required']
  32.       }
  33.     });
  35.     var User = db.model('User', userSchema);
  36.     var user = new User();
  37.     var error;
  39.     user.phone = '555.0123';
  40.     user.name = 'test';
  41.     user.validate(function(error) {
  42.       assert.ok(error);
  43.       assert.equal(error.errors['phone'].message,
  44.         '555.0123 is not a valid phone number!');
  45.       assert.equal(error.errors['name'].message,
  46.         'Validator failed for path `name` with value `test`');
  47.     });

[

验证错误 ](#验证错误)

验证失败返回的 err 包含一个 ValidatorError 对象。 每一个 ValidatorError 都有 kind、path、 value 和 message 属性。 ValidatorError 也可能有 reason 属性， 如果检验器抛出错误，这个属性会包含该错误原因。

  2.     var toySchema = new Schema({
  3.       color: String,
  4.       name: String
  5.     });
  7.     var validator = function(value) {
  8.       return /red|white|gold/i.test(value);
  9.     };
  10.     toySchema.path('color').validate(validator,
  11.       'Color `{VALUE}` not valid', 'Invalid color');
  12.     toySchema.path('name').validate(function(v) {
  13.       if (v !== 'Turbo Man') {
  14.         throw new Error('Need to get a Turbo Man for Christmas');
  15.       }
  16.       return true;
  17.     }, 'Name `{VALUE}` is not valid');
  19.     var Toy = db.model('Toy', toySchema);
  21.     var toy = new Toy({ color: 'Green', name: 'Power Ranger' });
  23.     toy.save(function (err) {
  24.       // `err` is a ValidationError object
  25.       // `err.errors.color` is a ValidatorError object
  26.       assert.equal(err.errors.color.message, 'Color `Green` not valid');
  27.       assert.equal(err.errors.color.kind, 'Invalid color');
  28.       assert.equal(err.errors.color.path, 'color');
  29.       assert.equal(err.errors.color.value, 'Green');
  31.       // mongoose 5 新特性，如果验证器抛错，
  32.       // mongoose 会使用该错误信息。如果验证器返回 `false`，
  33.       // mongoose 会使用 'Name `Power Ranger` is not valid'。
  34.       assert.equal(err.errors.name.message,
  35.         'Need to get a Turbo Man for Christmas');
  36.       assert.equal(err.errors.name.value, 'Power Ranger');
  37.       // If your validator threw an error, the `reason` property will contain
  38.       // the original error thrown, including the original stack trace.
  39.       assert.equal(err.errors.name.reason.message,
  40.         'Need to get a Turbo Man for Christmas');
  42.       assert.equal(err.name, 'ValidationError');
  43.     });

[

嵌套对象中的 Required 检验器 ](#嵌套对象中的-required-检验器)

定义嵌套对象的验证器需要特别注意。

  2.     var personSchema = new Schema({
  3.       name: {
  4.         first: String,
  5.         last: String
  6.       }
  7.     });
  9.     assert.throws(function() {
  10.       // 这里会报错，因为 'name' 不是“完整成熟的路径”
  11.       personSchema.path('name').required(true);
  12.     }, /Cannot.*'required'/);
  14.     // 要让嵌套对象 required，要使用单独的嵌套 schema
  15.     var nameSchema = new Schema({
  16.       first: String,
  17.       last: String
  18.     });
  20.     personSchema = new Schema({
  21.       name: {
  22.         type: nameSchema,
  23.         required: true
  24.       }
  25.     });
  27.     var Person = db.model('Person', personSchema);
  29.     var person = new Person();
  30.     var error = person.validateSync();
  31.     assert.ok(error.errors['name']);

[

Update 验证器 ](#update-验证器)

上例中，你学习了 document 的验证。Mongoose 还支持验证 update() 和 findOneAndUpdate() 操作。 Update 验证器默认关闭，如需打开，请另外配置 runValidators。

注意：update 验证器默认关闭是因为里面有几个注意事项必须先了解。

  2.     var toySchema = new Schema({
  3.       color: String,
  4.       name: String
  5.     });
  7.     var Toy = db.model('Toys', toySchema);
  9.     Toy.schema.path('color').validate(function (value) {
  10.       return /blue|green|white|red|orange|periwinkle/i.test(value);
  11.     }, 'Invalid color');
  13.     var opts = { runValidators: true };
  14.     Toy.update({}, { color: 'bacon' }, opts, function (err) {
  15.       assert.equal(err.errors.color.message,
  16.         'Invalid color');
  17.     });

[

Update 验证器与 this ](#update-验证器与-this)

update 验证器和 document 验证器有诸多不同。 上面的颜色验证函数，this 指向验证中的 document 。 然而 update 验证器运行时，被更新文档不一定存在于服务器内存， 所以 this 值未定义。

  2.     var toySchema = new Schema({
  3.       color: String,
  4.       name: String
  5.     });
  7.     toySchema.path('color').validate(function(value) {
  8.       // When running in `validate()` or `validateSync()`, the
  9.       // validator can access the document using `this`.
  10.       // Does **not** work with update validators.
  11.       if (this.name.toLowerCase().indexOf('red') !== -1) {
  12.         return value !== 'red';
  13.       }
  14.       return true;
  15.     });
  17.     var Toy = db.model('ActionFigure', toySchema);
  19.     var toy = new Toy({ color: 'red', name: 'Red Power Ranger' });
  20.     var error = toy.validateSync();
  21.     assert.ok(error.errors['color']);
  23.     var update = { color: 'red', name: 'Red Power Ranger' };
  24.     var opts = { runValidators: true };
  26.     Toy.update({}, update, opts, function(error) {
  27.       // The update validator throws an error:
  28.       // "TypeError: Cannot read property 'toLowerCase' of undefined",
  29.       // because `this` is **not** the document being updated when using
  30.       // update validators
  31.       assert.ok(error);
  32.     });

[

context 选项 ](#context-选项)

context 选项允许你把 update 验证器的 this 设置为 query。

  2.     toySchema.path('color').validate(function(value) {
  3.       // When running update validators with the `context` option set to
  4.       // 'query', `this` refers to the query object.
  5.       if (this.getUpdate().$set.name.toLowerCase().indexOf('red') !== -1) {
  6.         return value === 'red';
  7.       }
  8.       return true;
  9.     });
  11.     var Toy = db.model('Figure', toySchema);
  13.     var update = { color: 'blue', name: 'Red Power Ranger' };
  14.     // Note the context option
  15.     var opts = { runValidators: true, context: 'query' };
  17.     Toy.update({}, update, opts, function(error) {
  18.       assert.ok(error.errors['color']);
  19.     });

[

Update 验证器字段路径 ](#update-验证器字段路径)

另一个关键不同点是 update 验证器只运行于更新的字段。 下例中，因为 'name' 在更新操作未被指定，所以此次更新操作成功。

使用 update 验证器的时候， required 验证器只会在你对某个字段显式使用 $unset 才会触发。

  2.     var kittenSchema = new Schema({
  3.       name: { type: String, required: true },
  4.       age: Number
  5.     });
  7.     var Kitten = db.model('Kitten', kittenSchema);
  9.     var update = { color: 'blue' };
  10.     var opts = { runValidators: true };
  11.     Kitten.update({}, update, opts, function(err) {
  12.       // 即使 'name' 没有指定也操作成功了
  13.     });
  15.     var unset = { $unset: { name: 1 } };
  16.     Kitten.update({}, unset, opts, function(err) {
  17.       // 'name' required， 操作失败
  18.       assert.ok(err);
  19.       assert.ok(err.errors['name']);
  20.     });

[

Update 验证器只运行于指定字段路径 ](#update-验证器只运行于指定字段路径)

最后要注意的是：update 验证器只运行于下列更新操作：

  • $set
  • $unset
  • $push (>= 4.8.0)
  • $addToSet (>= 4.8.0)
  • $pull (>= 4.12.0)
  • $pullAll (>= 4.12.0)

例如，以下 update 成功执行，不管 number 的值，因为 update 验证器 无视 $inc 。同样， $push、$addToSet、 $pull 和 $pullAll 验证器 不会对数组自身验证，只会对数组中的元素验证。

  2.     var testSchema = new Schema({
  3.       number: { type: Number, max: 0 },
  4.       arr: [{ message: { type: String, maxlength: 10 } }]
  5.     });
  7.     // Update 验证器不会作检查，所以你再仍然可以 `$push` 两个元素到数组 
  8.     // 只要他们的 `message` 没有超长
  9.     testSchema.path('arr').validate(function(v) {
  10.       return v.length < 2;
  11.     });
  13.     var Test = db.model('Test', testSchema);
  15.     var update = { $inc: { number: 1 } };
  16.     var opts = { runValidators: true };
  17.     Test.update({}, update, opts, function(error) {
  18.       // 这里不会报错
  19.       update = { $push: [{ message: 'hello' }, { message: 'world' }] };
  20.       Test.update({}, update, opts, function(error) {
  21.         // 这里也不会报错
  22.       });
  23.     });

[

$push 和 $addToSet ](#$push-和-$addtoset)

4.8.0 新特性： update 验证器也运行于 $push 和 $addToSet

  2.     var testSchema = new Schema({
  3.       numbers: [{ type: Number, max: 0 }],
  4.       docs: [{
  5.         name: { type: String, required: true }
  6.       }]
  7.     });
  9.     var Test = db.model('TestPush', testSchema);
  11.     var update = {
  12.       $push: {
  13.         numbers: 1,
  14.         docs: { name: null }
  15.       }
  16.     };
  17.     var opts = { runValidators: true };
  18.     Test.update({}, update, opts, function(error) {
  19.       assert.ok(error.errors['numbers']);
  20.       assert.ok(error.errors['docs']);
  21.     });