JavaScript Regular Expression Validation

Question

I'm attempting to validate a field name to match a certain format in JavaScript using Regular Expressions.

I need the string inputted to resemble this:
word\word\word
So anything inputted can't be blank, and it must be three words seperated by a backslash.

This is the code i'm working with, but i'm not sure if the pattern is the right syntax?!!

    function validateResourceName() {
       //get posted resource name value
       var inputString = document.getElementById("resourceName").value;
       //should be in the word\word\word format
       var pattern=/[a-Z|/\\/|a-Z|/\\/|a-Z\s]/;

       //If the inputString is NOT a match
       if (!pattern.test(inputString)) {
        alert("not a match");
       }
      else
      {
            alert("match");
      }
    }

Any help will be very appreciated!!!

/^[a-zA-Z]+\/[a-zA-Z]+\/[a-zA-Z]+$/ will evaluate it for you — user1496463
– user1496463, Commented Aug 14, 2015 at 8:01

Dal Hundal · Accepted Answer · 2015-08-14 08:05:27Z

4

Try /^[a-z]+\\[a-z]+\\[a-z]+$/

function validateResourceName() {
  //get posted resource name value
  var inputString = document.getElementById("resourceName").value;
  //should be in the word\word\word format
  var pattern=/^[a-z]+\\[a-z]+\\[a-z]+$/
  //If the inputString is NOT a match
  if (!pattern.test(inputString)) {
    alert("not a match");
  } else {
    alert("match");
  }
}

If you want to allow the word matching to be case insensitive;

`/^[a-z]+\\[a-z]+\\[a-z]+$/i`

If you want to be a bit more broad with what you define as a 'word', and allow it to consist of alphanumeric characters and underscore;

`/^\w+\\\w+\\\w+$/i`

edited Aug 14, 2015 at 8:05

answered Aug 14, 2015 at 7:58

Dal Hundal

3,32218 silver badges21 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

T.J. Crowder · Accepted Answer · 2015-08-14 08:04:14Z

3

If by word you mean the English letters a-z in upper or lower case, then:

/^(?:[a-z]+\\){2}[a-z]+$/i

That says:

^ Beginning of string
(?:...) Non-capturing group
[a-z]+ One or more letters a-z (or A-Z because of the i flag at the end). If you also want to allow some other characters, just add them to the [a-z] after the z. If you want to allow hyphens, add \- to it (you need the backslash, depending on where you put the hyphen, so I just always include it). Note that this is very English-centric, and even in English sometimes people write borrowed words with their non-English letters, such as résumé.
\\ Backslash
{2} Repeated twice
(Then another word)
$ End of string

The issues with your expression are:

[a-Z] Is invalid because the range is out of order (Z comes before a). If it were valid (or if you wrote [Z-a]), it would matches everything between Z and a, which isn't just a-z and A-Z
\\/ Requires a backslash and then a slash
| is an alternation (this or that)
\s is whitespace

edited Aug 14, 2015 at 8:04

answered Aug 14, 2015 at 7:57

T.J. Crowder

1.1m201 gold badges2k silver badges2k bronze badges

3 Comments

CodingIntrigue Over a year ago

I get Invalid regular expression in Chrome using [a-Z]. Range out of order in character class

T.J. Crowder Over a year ago

@RGraham: I'm glad to hear that. :-) Yeah, it would have to be [Z-a] to get the order right, since Z comes before a. (Some regex engines in other languages just quietly reverse the range for you, I think.)

T.J. Crowder Over a year ago

And of course, Z-a wouldn't match A-Y or b-z. :-)

Raghavendra · Accepted Answer · 2015-08-14 08:07:12Z

1

you can just use this \w+\\\w+\\\w+

or

[a-zA-Z]+(\\[a-zA-Z]+){2}

edited Aug 14, 2015 at 8:07

answered Aug 14, 2015 at 7:56

Raghavendra

3,5901 gold badge19 silver badges18 bronze badges

5 Comments

T.J. Crowder Over a year ago

\w does more than what he appears to want (it includes digits and such)

CodingIntrigue Over a year ago

This would include digits and underscores

Raghavendra Over a year ago

pls see wiki they clearly mention to match words we should use \w

T.J. Crowder Over a year ago

@raghavendra: What the wiki wants and what the OP wants aren't necessarily the same thing. In particular, underscores aren't part of a "word" in English.

T.J. Crowder Over a year ago

@raghavendra: Well, the OP hasn't weighed in with what they consider a "word," so... (But probably not underscores, to be fair.)

buckley · Accepted Answer · 2015-08-14 07:59:08Z

0

This should do it

^\w+\\\w+\\\w+$

In javascript

if (/^\w+\\\w+\\\w+$/.test(subject)) {
    // Successful match
} else {
    // Match attempt failed
}

answered Aug 14, 2015 at 7:59

buckley

14.2k3 gold badges58 silver badges63 bronze badges

Comments

Ivar · Accepted Answer · 2023-05-02 14:49:21Z

0

Try this one. See JSFiddle for the code demo.

Regex

/(\w)*\\(?!\\)(\w)*\\(?!\\)(\w)*(?!\\)/g

JavaScript

function validateResourceName(string) {
 var pattern = /(\w)*\\(?!\\)(\w)*\\(?!\\)(\w)*(?!\\)/g;
  if (!pattern.test(string)) {
    alert("not a match");
  } else {
    alert("match");
  }
}

edited May 2, 2023 at 14:49

Ivar

6,97912 gold badges58 silver badges69 bronze badges

answered Aug 14, 2015 at 8:02

Jijo John

1,3759 silver badges21 bronze badges

1 Comment

CodingIntrigue Over a year ago

This allows for an empty word: var string = '\\\\';

pankaj · Accepted Answer · 2024-02-23 22:25:51Z

Here I came up with a robust solution where you can find everything in one place. In function, you can find all types of validation in the same method with the proper message.

For JavaScript Users...

function validateInput(input,type,max,min,confirmPassword ='' ){
            input = input.toLocaleString();

            const validateMaxLength = (maxLen) => input.length <= maxLen;
            const validateMinLength = (minLen) => input.length >= minLen;
            const validateNotEmpty = () => input.trim() !== '';

            if( !validateMaxLength(max) ){
                return {status:'error',msg:'String is too long.'};
            }
            else if( !validateMinLength(min))
                return    {status:'error',msg:'String is too short.'};

            else if( !validateNotEmpty() ){
                return   {status:'error',msg:'String can not empty.'};
            }
           else if( type === 'email'){
                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
                if( !emailRegex.test(input) ){
                    return  {status:'error',msg:'Email is not valid.'};;
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'alphanumeric' )
            {
                const alphanumericRegex = /^[a-zA-Z0-9\s]+$/;
                if( !alphanumericRegex.test(input) ){
                    return  {status:'error',msg:'String is not valid.'};
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'onlyString' )
            {
                const stringRegex = /^[a-zA-Z\s]+$/;
                if( !stringRegex.test(input) ){
                    return  {status:'error',msg:'Email is not valid.'};
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'onlyNumber' )
            {
                const numberRegex = /^[0-9]+$/;
                if( !numberRegex.test(input)  ){
                    return  {status:'error',msg:'Number is not valid.'};
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'mobileNumber' )
            {
                const mobileRegex = /^[+\s0-9]+$/;

                if( !mobileRegex.test(input) ){
                    return  {status:'error',msg:'Mobile number is invalid.'};
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'alphanumericWithSpecial' )
            {
                const alphanumericSpecialRegex = /^[a-zA-Z0-9!@#$%&*()_+\-=\[\]{};':"\\|,.<>\/?\s]*$/;

                if( !alphanumericSpecialRegex.test(input) ){
                    return  {status:'error',msg:'String is not valid.'};
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'webURL' )
            {
                const urlRegex = /^(ftp|http|https):\/\/[^ "]+$/;

                if( !urlRegex.test(input) ){
                    return  {status:'error',msg:'Web url is not valid.'};
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'confirmPassword' )
            {
                if (input !== confirmPassword.toString()) {
                    return  {status:'error',msg:'Passwords do not match.'};
                }
                return {status:'success',msg:""};
            }
                return  {status:'error',msg:"Invalid Type"};
        }

Use Case :

 Console.log( validateInput("[email protected]","email",80,10 ) )

For VUE JS :

 methods:{  
      validateInput(input,type,max,min,confirmPassword ='' ){
            input = input.toLocaleString();

            const validateMaxLength = (maxLen) => input.length <= maxLen;
            const validateMinLength = (minLen) => input.length >= minLen;
            const validateNotEmpty = () => input.trim() !== '';

            if( !validateMaxLength(max) ){
                return {status:'error',msg:'String is too long.'};
            }
            else if( !validateMinLength(min))
                return    {status:'error',msg:'String is too short.'};

            else if( !validateNotEmpty() ){
                return   {status:'error',msg:'String can not empty.'};
            }
           else if( type === 'email'){
                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
                if( !emailRegex.test(input) ){
                    return  {status:'error',msg:'Email is not valid.'};;
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'alphanumeric' )
            {
                const alphanumericRegex = /^[a-zA-Z0-9\s]+$/;
                if( !alphanumericRegex.test(input) ){
                    return  {status:'error',msg:'String is not valid.'};
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'onlyString' )
            {
                const stringRegex = /^[a-zA-Z\s]+$/;
                if( !stringRegex.test(input) ){
                    return  {status:'error',msg:'Email is not valid.'};
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'onlyNumber' )
            {
                const numberRegex = /^[0-9]+$/;
                if( !numberRegex.test(input)  ){
                    return  {status:'error',msg:'Number is not valid.'};
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'mobileNumber' )
            {
                const mobileRegex = /^[+\s0-9]+$/;

                if( !mobileRegex.test(input) ){
                    return  {status:'error',msg:'Mobile number is invalid.'};
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'alphanumericWithSpecial' )
            {
                const alphanumericSpecialRegex = /^[a-zA-Z0-9!@#$%&*()_+\-=\[\]{};':"\\|,.<>\/?\s]*$/;

                if( !alphanumericSpecialRegex.test(input) ){
                    return  {status:'error',msg:'String is not valid.'};
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'webURL' )
            {
                const urlRegex = /^(ftp|http|https):\/\/[^ "]+$/;

                if( !urlRegex.test(input) ){
                    return  {status:'error',msg:'Web url is not valid.'};
                }
                return {status:'success',msg:""};
            }
            else if ( type === 'confirmPassword' )
            {
                if (input !== confirmPassword.toString()) {
                    return  {status:'error',msg:'Passwords do not match.'};
                }
                return {status:'success',msg:""};
            }
                return  {status:'error',msg:"Invalid Type"};
        } ,
    debounceEmailValidation: _.debounce( function (){
          let d =  this.validateInput(this.email,'email',50,10 );
          if( d.status === 'error'){
                this.errors={email:[ d.msg]};
                return
            }
            this.errors={email:[]};
        }, 1000),
  },
 watch:{
        'email':{
            handler(){
                 this.debounceEmailValidation();
            }
        }
     },

debounceMobileValidation using debounce is not mandatory. I used it because there was a need for a program.

Collectives™ on Stack Overflow

JavaScript Regular Expression Validation

6 Answers 6

Comments

3 Comments

5 Comments

Comments

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

3 Comments

5 Comments

Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related