Yes! Let's validate some names with RegEx.

After all, we know that all people must have a first and last name, right? And no single person has more than three or four names total? And no doubt the same person will forever be identifiable by the same name?

Plus, we know that no modern culture uses patronymic naming and people in the same nuclear family must have the same last name, right?

Well, we can at least assume that people do not have single character names, right? And there are no names that use special characters, symbols, or apostrophes?

I think your choice of RegEx to validate names is missing the point: this is a huge unwieldy problem and, even if you massively restrict the scope of names you allow, you will forever suffer the risk of false negatives and you will be turning away people from other cultures and languages. In other words, I don't think that even attempting to validate names is worth your time.

Don't forget about names like:

• Mathias d'Arras
• Martin Luther King, Jr.
• Hector Sausage-Hausen

This should do the trick for most things:

/^[a-z ,.'-]+$/i

OR Support international names with super sweet unicode:

/^[a-zA-ZàáâäãåąčćęèéêëėįìíîïłńòóôöõøùúûüųūÿýżźñçčšžæÀÁÂÄÃÅĄĆČĖĘÈÉÊËÌÍÎÏĮŁŃÒÓÔÖÕØÙÚÛÜŲŪŸÝŻŹÑßÇŒÆČŠŽ∂ð ,.'-]+$/u

I have written this function for your purpose.

/**
 * This function checks if first name
 * is valid. Keep in mind this is
 * not the proper solution. It will
 * work only for names written in
 * latin letters.
 * @example
 *   isFirstNameValid('Ivan')
 *   will return true.
 *   isFirstNameValid('IvaN')
 *   will return false.
 * @author Georgi Naumov
 * [email protected] for contacts and
 * suggestions
 **/
const isFirstNameValid = (firstName) => 
  /^[a-zA-z][a-z]+$/.test(firstName)

Edit: I have implemented a solution with unicode support for the people with a similar problem in the future. It supports Latin, Hebrew and Cyrillic. If you want to support another cultures you need to provide regexes for them inside cultures hash.

const isFirstNameValidWithUnicodeSupport = (firstName, culture = 'LATIN') => {
  const cultures = {
    HEBREW: /^[\u0590-\u05FF]{2,}$/,
    CYRILLIC: /^[\u0410-\u042F\u0430-\u044F][\u0430-\u044F]+$/,
    LATIN: /^[A-Za-z][a-z]+$/,
  };
  return  cultures[culture].test(firstName);
}

This returns true because is valid name in latin
alphabet. 
console.log(isFirstNameValidWithUnicodeSupport('Ivan'));
This returns true because is valid name in cyrillic
alphabet. 
console.log(isFirstNameValidWithUnicodeSupport('Иван', 'CYRILLIC'));
This returns false because is valid name in cyrillic
alphabet but there is a space in the end. 
console.log(isFirstNameValidWithUnicodeSupport('Иван ',  'CYRILLIC'));
This returns true because is valid name in hebrew
alphabet. 
console.log(isFirstNameValidWithUnicodeSupport('אגרת',  'HEBREW'));
This returns false because is valid name in hebrew
but is whole name containing spaces. Not only first name.
console.log(isFirstNameValidWithUnicodeSupport('אגרת בת מחלת',  'HEBREW'));

Edit2: Probably better solution is xregexp library if you want to use library for that purpose. https://github.com/slevithan/xregexp

Try this regex

^^- ')(?=(?![a-z]+[A-Z]))(?=(?!.*[A-Z][A-Z]))(?=(?!.*[- '][- '.]))(?=(?!.*[.][-'.]))[A-Za-z- '.]{2,}$

Demo

Edited Oct 13, 2024

My latest solution for int names:

^(?=([A-ZÀ-ÝŐŰẞŒ]|([a-zß-ÿőűœ][ '])))(?=(?![a-zß-ÿőűœ]+[A-ZÀ-ÝŐŰẞŒ]))(?=(?!.*[A-ZÀ-ÝŐŰẞŒ][A-ZÀ-ÝŐŰẞŒ]))(?=(?!.*[- '][- ']))[A-ZÀ-ÝŐŰẞŒß-ÿőűœa-z- ']{2,}([a-zß-ÿőűœ]|(, Jr.))$

function myFunction() {
    
  const pattern = "^(?=([A-ZÀ-ÝŐŰẞŒ]|([a-zß-ÿőűœ][ '])))(?=(?![a-zß-ÿőűœ]+[A-ZÀ-ÝŐŰẞŒ]))(?=(?!.*[A-ZÀ-ÝŐŰẞŒ][A-ZÀ-ÝŐŰẞŒ]))(?=(?!.*[- '][- ']))[A-ZÀ-ÝŐŰẞŒß-ÿőűœa-z- ']{2,}([a-zß-ÿőűœ]|(, Jr.))$";
    var regex = new RegExp(pattern, 'gm');
    var a = document.getElementById("myText");
  var b = a.value;
  var c = regex.test(b);
  var d = document.getElementById("result") ;
  d.innerHTML = "Result:";
  if(b != ""){
      if(c){
          d.innerHTML += " passed";
      }
      else{
        d.innerHTML += " failed";
        }
  }
  else{
    return
  }
}

input[type=text] {
  width: 99%;
  padding: 4px;
  margin: 8px 0;
  display: inline-block;
  border: 1px solid #ccc;
  box-sizing: border-box;
}
button {
  background-color: #04AA6D;
  color: white;
  padding: 4px;
  border: none;
  cursor: pointer;
  width: 25%;
}

button:hover {
  opacity: 0.8;
}

<h2>Name Validation Regex Pattern </h2>
<div class="container">
      <label for="name"><b>Name</b></label>
        <input type="text" id="myText"  placeholder="Enter Your Name" name="name" value="">
</div>
 <div class="container">

<button onclick="myFunction()">Try it</button>
<p id="result"> Result: </p>
</div>
</div>

In your case it would be easiest to define a "blacklist" instead of a "whitelist", as you know, what you don't want to have in the string, but don't quite know, what you need tolerate. As @AntonH suggested, you should check for

[^@ ?!\,$%]+

instead of a giant and possibly incomplete "whitelist" of characters and ranges. This means "a string of length one or more containing none of the specified characters.

You can use

^[a-zA-Z]{4,}(?: [a-zA-Z]+){0,2}$

See the regex demo

This will work with names starting with both lower- and upper-cased letters.

• ^ - start of string
• [a-zA-Z]{4,} - 4 or more ASCII letters
• (?: [a-zA-Z]+){0,2} - 0 to 2 occurrences of a space followed with one or more ASCII letters
• $ - end of string.

If you need to restrict the words to start with Uppercase letters, you can use

^[A-Z][a-zA-Z]{3,}(?: [A-Z][a-zA-Z]*){0,2}$