Mungo - Validierung der E-Mail-syntax

Ich habe eine mongoose-schema für Benutzer (UserSchema) und ich möchte, um zu überprüfen, ob die E-Mail hat die richtige syntax. Die Bestätigung, dass ich derzeit verwenden, ist die folgende:

UserSchema.path('email').validate(function (email) {
  return email.length
}, 'The e-mail field cannot be empty.')

Ist dies jedoch nur überprüft, wenn das Feld leer ist oder nicht, und nicht für die syntax.

Tut etwas, was bereits vorhanden ist, konnte ich wieder verwenden oder müsste ich, um mit meiner eigenen Methode, und rufen, daß es in der validate-Funktion?

InformationsquelleAutor Tamas | 2013-08-02

14

Können Sie einen regex verwenden. Werfen Sie einen Blick auf diese Frage: Validierung der E-Mail-Adresse in JavaScript?

Ich habe dies in der Vergangenheit.
```
UserSchema.path('email').validate(function (email) {
   var emailRegex = /^([\w-\.]+@([\w-]+\.)+[\w-]{2,4})?$/;
   return emailRegex.test(email.text); //Assuming email has a text attribute
}, 'The e-mail field cannot be empty.')
```
- Genial! Ich wusste nicht, über die test () - Methode.
- Definieren Sie die regex außerhalb der Funktion für eine bessere Leistung.
- Diese regex nicht überprüft, einige gültige E-Mails, wie diese beinhalten das Pluszeichen auf der linken Seite.
- Was genau ist dieses email.text - Attribut?
- die E-Mail.text-Attribut ist im wesentlichen die E-Mail-Adresse von string. Zum Beispiel "[email protected]"
- kann nicht helfen, aber beachten Sie die end-Teil, ist, dass jedes Wort, das zwischen 2-4 chars lange? bedeutet das, dass eine E-Mail wie [email protected] wird nicht funktionieren? die regex ist wohl falsch.
InformationsquelleAutor dannyp32

konnte man auch mit dem match oder die überprüfen Eigenschaft für die Validierung in der schema -

Beispiel

var validateEmail = function(email) {
    var re = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
    return re.test(email)
};

var EmailSchema = new Schema({
    email: {
        type: String,
        trim: true,
        lowercase: true,
        unique: true,
        required: 'Email address is required',
        validate: [validateEmail, 'Please fill a valid email address'],
        match: [/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/, 'Please fill a valid email address']
    }
});

schöne Lösung. aber nur problem ist, es ist nicht vorbei eslint regex Regel. könnten Sie bitte aktualisieren?
Was ist der Unterschied zwischen validate und match?
gibt eine Funktion, die aufgerufen werden, für die Validierung (nicht verwenden müssen regexes), match gibt eine regex Validierung direkt.

InformationsquelleAutor ramon22

53

Benutze ich validator für meine Eingabe sanitäre Einrichtungen, und es kann verwendet werden, in einer ziemlich coolen Weise.

Installieren Sie es, und verwenden Sie dann etwa so:
```
import { isEmail } from 'validator';
//... 

const EmailSchema = new Schema({
    email: { 
        //... other setup
        validate: [ isEmail, 'invalid email' ]
    }
});
```
Werk behandeln, und liest schön.
- für ES5 🙂 , const validator = require('validator'); validieren: [validator.isEmail, 'invalid email'],
- const war nicht verfügbar, in ES5 leider.
- aha sorry ich konnte nicht editieren, "var" 🙂
- kleiner chuck mit import isEmail from 'validator/lib/isEmail';
InformationsquelleAutor Kris Selbekk
7

Den validator
somit nicht gut spielen mit Mungo, um loszuwerden, das Warnung eingestellt isAsync auf false
```
const validator = require('validator');

email:{
type:String,
validate:{
      validator: validator.isEmail,
      message: '{VALUE} is not a valid email',
      isAsync: false
    }
}
```
- ohne isAsync: false Validierung nicht funktioniert hat in meinem Fall, ich war mit Mungo mit Versprechen. mongoose version 5.2.13
InformationsquelleAutor Patryk Acuña

Aus irgendeinem Grund ~~validate: [ isEmail, 'Invalid email.']~~ nicht gut spielen mit validate() tests.

const user = new User({ email: 'invalid' });
try {
  const isValid = await user.validate();
} catch(error) {
  expect(error.errors.email).to.exist; //... it never gets to that point.
}

Aber Mungo 4.x (es könnten auch ältere Versionen) hat andere alternative Optionen, die hand in hand arbeiten mit Unit tests.

Einzelnen Prüfer:

email: {
  type: String,
  validate: {
    validator: function(value) {
      return value === '[email protected]';
    },
    message: 'Invalid email.',
  },
},

Mehrere Prüfer:

email: {
  type: String,
  validate: [
    { validator: function(value) { return value === '[email protected]'; }, msg: 'Email is not handsome.' },
    { validator: function(value) { return value === '[email protected]'; }, msg: 'Email is not awesome.' },
  ],
},

Wie überprüft wird, E-Mail:

Meine Empfehlung: Lassen Sie das zu Experten, die investiert haben Hunderte von Stunden in den Aufbau der richtigen Validierungs-tools. (schon beantwortet hier auch)

npm install --save-dev-validator

import { isEmail } from 'validator';
...
validate: { validator: isEmail , message: 'Invalid email.' }

InformationsquelleAutor zurfyx

E-Mail-Typ für Schemata - Mungo-Typ-E-Mail

var mongoose = require('mongoose');
require('mongoose-type-email');

var UserSchema = new mongoose.Schema({
    email: mongoose.SchemaTypes.Email
});

InformationsquelleAutor o.z

email: {
    type: String,
    match: [/^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/, `Please fill valid email address`],
    validate: {
      validator: function() {
        return new Promise((res, rej) =>{
          User.findOne({email: this.email, _id: {$ne: this._id}})
              .then(data => {
                  if(data) {
                      res(false)
                  } else {
                      res(true)
                  }
              })
              .catch(err => {
                  res(false)
              })
        })
      }, message: 'Email Already Taken'
    }
  }

Folgen Sie bitte: stackoverflow.com/help/how-to-answer
NICHT empfehlen einen solchen Ansatz. Wie definieren Sie User schema und verwenden Sie User.findOne vor schema deklariert wurde.

InformationsquelleAutor user11195629

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.