Home

Index

How to use the isEmail function from validator

Find comprehensive JavaScript validator.isEmail code examples handpicked from public code repositorys.

validator.isEmail is a function that takes a string as input and returns a boolean value indicating whether or not the string is a valid email address.

validations.js

64
65
66
67
68
69
70
71
72
73
  customMessage
) {
  return checkParam(
    paramName,
    translator(customMessage || 'email', { paramName: paramName }, locals),
    validator.isEmail
  )
}

validations.contains = function contains(paramName, str, customMessage) {

157

+ 5 other calls in file

chriso.validator.js.md?plain=1

GitHub: Tombarr/open-source-words

41
42
43
44
45
46
47
48
49
50
The library can be loaded either as a standalone script, or through an [AMD][amd]-compatible loader

```html
<script type="text/javascript" src="validator.min.js"></script>
<script type="text/javascript">
  validator.isEmail('foo@bar.com'); //=> true
</script>
```

The library can also be installed through [bower][bower]

+ 25 other calls in file

How does validator.isEmail work?

validator.isEmail works by applying a regular expression pattern to the input string and checking if it matches the pattern for a valid email address.

The regular expression pattern used by validator.isEmail is designed to be a reasonably accurate representation of the syntax specified in the RFC 5322 standard for email addresses. This includes checking for the presence of an "@" symbol, a domain name with at least one "." character, and valid characters in each part of the address.

If the input string matches the pattern for a valid email address, validator.isEmail returns true. Otherwise, it returns false.

User.js

GitHub: airqo-platform/AirQo-api

40
41
42
43
44
45
46
47
48
49
  unique: true,
  required: [true, "Email is required"],
  trim: true,
  validate: {
    validator(email) {
      return validator.isEmail(email);
    },
    message: "{VALUE} is not a valid email!",
  },
},

+ 2 other calls in file

validation-helpers.js

GitHub: theoephraim/flash-loan-dash

203
204
205
206
207
208
209
210
211
212
// It returns an array of cleaned and valid emails (trim, lowercase and non empty emails)
// If an email is invalid an error will also be thrown
if (!emails) return [];
let cleanEmails = _.map(emails, (e) => e.trim().toLowerCase());
cleanEmails = _.compact(cleanEmails);
const validEmails = _.filter(cleanEmails, (e) => validator.isEmail(e));
if (cleanEmails.length !== validEmails.length) {
  return new Error('The email "#{email}" is not valid.');
}
return validEmails;

+ 3 other calls in file

Ai Example

1
2
3
4
5
6
const validator = require("validator");

const email = "example@example.com";
const isValidEmail = validator.isEmail(email);

console.log(isValidEmail); // true

In this example, we first import the validator library, which includes the isEmail function. We then define a string variable email containing an email address. We call validator.isEmail(email) to check if the email address is valid, and store the result in the isValidEmail variable. Finally, we log the value of isValidEmail to the console, which in this case will output true since 'example@example.com' is a valid email address.

bundle.js

GitHub: bevacqua/infer

376
377
378
379
380
381
382
383
384
385
}

function infer (input, placeholder) {
  var p = placeholder || 'you';
  var email = String(input);
  var valid = validator.isEmail(email);
  if (!valid) {
    return p;
  }
  var local = email.split('@')[0];

+ 3 other calls in file

index.js

GitHub: slick-codes/json-validace

337
338
339
340
341
342
343
344
345
346
// check if value is a valid array
else if (type === 'array')
    return Array.isArray(value)
// check if value is a valid email
else if (type === 'email')
    return validator.isEmail(value ?? "")
//  check if value is a jwt
else if (type === 'jwt')
    return validator.isJWT(value ?? "")
// check if value is a valid mongodb id

+ 4 other calls in file

app.js

GitHub: chentsulin/startLearningNodejs

-3

+ 3 other calls in file

common-validator.js

GitHub: ministryofjustice/help-with-prison-visits-internal

35
36
37
38
39
40
41
42
43
44
exports.isLessThanMaximumDifferentApprovedAmount = function (value) {
  return value <= parseInt(config.MAX_APPROVED_DIFFERENT_AMOUNT) && value !== null
}

exports.isEmail = function (value) {
  return validator.isEmail(value)
}

exports.isLessThanLength = function (value, length) {
  return validator.isLength(value, { max: length })

index.js

GitHub: justinsisley/marshall

223
224
225
226
227
228
229
230
231
232
case 'date':
  isValid = validator.isDate(stringValue);
  break;

case 'email':
  isValid = validator.isEmail(stringValue);
  break;

case 'fqdn':
  isValid = validator.isFQDN(stringValue);

+ 31 other calls in file

spell.js

GitHub: netbek/lichen

158
159
160
161
162
163
164
165
166
167
  'i'
);

if (
  (ignoreCurrency && validator.isCurrency(word)) ||
  (ignoreEmail && validator.isEmail(word)) ||
  (ignoreFqdn && validator.isFQDN(word)) ||
  (ignoreUrl && validator.isURL(word)) ||
  (ignoreUnits && unitFilter.test(word))
) {

express-validator2.js

GitHub: yinhaixiang/express-validator2

26
27
28
29
30
31
32
33
34
35
contains: function(rule, value) {
  return validator.contains(value, rule);
},
isEmail: function(rule, value) {
  if (rule) {
    return validator.isEmail(value);
  }
  return true;
},
isURL: function(rule, value) {

+ 5 other calls in file

validators.js

GitHub: mmerkes/express-route-validator

47
48
49
50
51
52
53
54
55
56
// an object which defaults to { allow_display_name: false, allow_utf8_local_part: true }.
// If allow_display_name is set to true, the validator will also match Display Name <email-address>.
// If allow_utf8_local_part is set to false, the validator will not allow any non-English
// UTF8 character in email address' local part.
isEmail: function (str, options) {
  return validator.isEmail(str, typeof options === 'object' ? options : undefined);
},
// isFQDN(str [, options]) - check if the string is a fully qualified domain name
// (e.g. domain.com). options is an object which defaults to
// { require_tld: true, allow_underscores: false, allow_trailing_dot: false }.

+ 17 other calls in file

security.js

GitHub: mboraski/HastyMobile

0
1
2
3
4
5
6
7
8
9
10
11
const validator = require('validator');


export const sanitizeAndValidateEmail = dirtyEmail => {
    const sanitizedEmail = validator.escape(dirtyEmail);
    const normalizedEmail = validator.normalizeEmail(sanitizedEmail);
    const validEmail = validator.isEmail(normalizedEmail);
    return validEmail ? normalizedEmail : '';
};


export const sanitizeToken = dirtyToken => validator.escape(dirtyToken);

admin.js

GitHub: HOLVERHURTADO/SprintRetoUnab

3
4
5
6
7
8
9
10
11
12
13


var controller = {
    save: function (req, res) {
        var params = req.body;
        var validate_name = !validator.isEmpty(params.name) && !validator.isNumeric(params.name);
        var validate_email = !validator.isEmpty(params.email) && validator.isEmail(params.email);
        var validate_password = !validator.isEmpty(params.password);
        
        if (validate_name && validate_email && validate_password) {
            var admin = new Admin();

nconf-validator.js

GitHub: mihirgokani007/nconf-validator

90
91
92
93
94
95
96
97
98
99
},
url: function(x) {
  check(x, "a URL", validator.isURL(x));
},
email: function(x) {
  check(x, "an email address", validator.isEmail(x));
},
ip: function(x) {
  check(x, "an IP address", validator.isIP(x));
},

string.js

GitHub: openage/express-api

20
21
22
23
24
25
26
27
28
29
30
31


const isEmail = function (key) {
    if (typeof key != "string") {
        throw new Error("key is not a string")
    }
    return validator.isEmail(key)
}


const isPhone = function (key) {
    if (typeof key != "string") {

ZSchema-browser.js

GitHub: BTWhite/z-schema

1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
},
"email": function (email) {
    if (typeof email !== "string") {
        return true;
    }
    return validator.isEmail(email, { "require_tld": true });
},
"hostname": function (hostname) {
    if (typeof hostname !== "string") {
        return true;

string.js

GitHub: openage/express-api

11
12
13
14
15
16
17
18
19
20
21
22
String.prototype.isObjectId = function () {
    return validator.isMongoId(this)
}


String.prototype.isEmail = function () {
    return validator.isEmail(this)
}


String.prototype.isPhone = function () {
    const code = this

user.js

GitHub: alejandropsan/master-fullstack

26
27
28
29
30
31
32
33
34
35

//? VALIDAR LOS DATOS
try{
    var validate_name = !validator.isEmpty(params.name);
    var validate_surname = !validator.isEmpty(params.surname);;
    var validate_email = validator.isEmail(params.email) && !validator.isEmpty(params.email);
    var validate_password = !validator.isEmpty(params.password);
}catch(err){
    return res.status(400).send({
        message: "Faltan datos por enviar"

+ 26 other calls in file

validate.js

GitHub: Diego-Carpio-Andia/PROYECT-NODEJS-MVC--REACT

8
9
10
11
12
13
14
15
16
17

let nick = !validator.isEmpty(params.nick) &&
            validator.isLength(params.nick, {min: 3, max: undefined});
         
let email = !validator.isEmpty(params.email) &&
             validator.isEmail(params.email);
     
let password = !validator.isEmpty(params.password); 
     
if(params.bio){

Other functions in validator

Sorted by popularity

validator.escape is the most popular function in validator (548 examples)

Other popular packages:

Home

About