Mongoose - valider l'e-mail de la syntaxe

J'ai une mangouste schéma pour les utilisateurs (UserSchema) et je voudrais vérifier si le mail a le droit de syntaxe. La validation que j'utilise actuellement est la suivante:

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

Toutefois, cela vérifie seulement si le champ est vide ou pas, et pas pour la syntaxe.

Fait quelque chose existe déjà que j'ai pu réutiliser ou devrais-je venir avec ma propre méthode et l'appeler à l'intérieur de la validation de la fonction?

InformationsquelleAutor Tamas | 2013-08-02
  1. 14

    Vous pouvez utiliser une expression régulière. Jetez un oeil à cette question: Valider l'adresse e-mail dans le JavaScript?

    J'ai utilisé dans le passé. 

    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.')
    • Génial! Je ne connaissais pas la méthode test() soit.
    • Vous devez définir l'expression régulière à l'extérieur de la fonction pour une meilleure performance.
    • Cette expression ne parvient pas à valider certains e-mails valides, tels que ceux qui comprennent le signe plus sur le côté gauche.
    • Qu'est-ce exactement ce email.text attribut?
    • l'e-mail.attribut de texte est fondamentalement la chaîne d'adresse électronique. Par exemple "[email protected]"
    • peut pas aider mais noter la fin de la partie, c'est que n'importe quel mot entre 2 à 4 caractères? est-ce à dire comme un e-mail [email protected] ne fonctionnera pas? la regex est probablement faux.

    InformationsquelleAutor dannyp32
  2. 78

    vous pouvez également utiliser la match ou la valider propriété pour la validation du schéma

    exemple

    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']
    }
});
    • solution sympa. mais le seul problème c'est que c'est pas en passant eslint regex règle. pourriez vous s'il vous plaît mettre à jour?
    • Quelle est la différence entre validate et match?
    • spécifie une fonction à appeler pour la validation (n'a pas besoin d'utiliser regexes), match spécifie une validation regex directement.
    InformationsquelleAutor ramon22
  3. 49

    - Je utiliser validateur pour mon entrée à l'assainissement, et il peut être utilisé dans une façon plutôt cool.

    De l'installer et de l'utiliser ensuite comme suit: 

    import { isEmail } from 'validator';
//... 

const EmailSchema = new Schema({
    email: { 
        //... other setup
        validate: [ isEmail, 'invalid email' ]
    }
});

    fonctionne un régal, et se lit agréablement.

    • pour ES5 🙂 , const validator = require('validator'); valider: [validator.isEmail, 'invalid email'],
    • const n'était pas disponible dans l'ES5, malheureusement.
    • ah désolé j'ai été absent à modifier pour "var" 🙂
    InformationsquelleAutor Kris Selbekk
  4. 7

    La validateur
    dosn pas de bien jouer avec la mangouste à se débarrasser de l'avertissement mis isAsync de faux

    const validator = require('validator');

email:{
type:String,
validate:{
      validator: validator.isEmail,
      message: '{VALUE} is not a valid email',
      isAsync: false
    }
}
    • sans isAsync: false , la validation n'a pas de travail dans mon cas, j'ai été en utilisant la mangouste avec une promesse. mangouste version 5.2.13
    InformationsquelleAutor Patryk Acuña
  5. 3

    Pour une raison quelconque validate: [ isEmail, 'Invalid email.'] ne joue pas bien avec 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.
}

    Mais mangouste 4.x (il peut fonctionner pour les versions plus anciennes aussi) a d'autres options qui travaillent main dans la main avec les tests Unitaires.

    Même validateur:

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

    Plusieurs validateurs:

    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.' },
  ],
},

    Comment valider email:

    Ma recommandation: laissons cela aux spécialistes, qui ont investi des centaines d'heures dans la construction correcte des outils de validation. (déjà répondu dans ici ainsi)

    npm install --save-dev validateur

    import { isEmail } from 'validator';
...
validate: { validator: isEmail , message: 'Invalid email.' }
    InformationsquelleAutor zurfyx
  6. 2
    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'
    }
  }
    • Veuillez suivre: stackoverflow.com/help/how-to-answer
    • ne recommande PAS une telle approche. Comme vous le définissez User schéma et que vous utilisez User.findOne avant de schéma a été déclarée.
    InformationsquelleAutor user11195629
  7. 1

    Type de messagerie pour les schémas - mongoose-type-e-mail

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

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