Regular expression for checking if capital letters are found consecutively in a string
RegexCapitalizeRegex Problem Overview
I want to know the regexp for the following case:
The string should contain only alphabetic letters. It must start with a capital letter followed by small letter. Then it can be small letters or capital letters.
^[A-Z][a-z][A-Za-z]*$
But the string must also not contain any consecutive capital letters. How do I add that logic to the regexp?
That is, HttpHandler
is correct, but HTTPHandler
is wrong.
Regex Solutions
Solution 1 - Regex
Whenever one writes [A-Z]
or [a-z]
, one explicitly commits to
processing nothing but 7-bit ASCII data from the 1960s. If that’s
really ok, then fine. But if it’s not ok, then Unicode character
properties exist to help you with handling modern character data.
There are three cases in Unicode, not two. Furthermore, you also have
noncased letters. Letters in general are specified by the \pL
property,
and each of these also belongs to exactly one of five subcategories:
- uppercase letters, specified with
\p{Lu}
; eg: AÇDZÞΣSSὩΙST - titlecase letters, specified with
\p{Lt}
; eg: LjDzSsᾨSt (actuallySs
andSt
are an upper- and then a lowercase letter, but they are what you get if you ask for the titlecase of ß and ſt, respectively) - lowercase letters, specified with
\p{Ll}
; eg: aαçdzςσþßᾡſt - modifier letters, specified with
\p{Lm}
; eg: ʰʲᴴᴭʺˈˠᵠꜞ - other letters, specified with
\p{Lo}
; eg: ƻאᎯᚦ京
You can take the complement of any of these, but do be careful, because
something like \P{Lu}
does not mean a letter that isn’t uppercase!
It means any character that isn’t an uppercase letter.
For a letter that’s either of uppercase or titlecase, use
[\p{Lu}\p{Lt}]
. So you could use for your pattern:
^([\p{Lu}\p{Lt}]\p{Ll}+)+$
If you don’t mean to limit the letters following the first to the “casing” letters alone, then you might prefer:
^([\p{Lu}\p{Lt}][\p{Ll}\p{Lm}\p{Lo}]+)+$
If you’re trying to match so-called “CamelCase” identifiers, then
the actual rules depend on the programming language, but usually include
the underscore character and the decimal numbers (\p{Nd}
), and may also
include a literal dollar sign and other language-dependent characters.
If so, you may wish to add some of these to one or the other of the two
character classes provided above.
For example, you may wish to add underscore to both but digits only to the second, leaving you with:
^([_\p{Lu}\p{Lt}][_\p{Nd}\p{Ll}\p{Lm}\p{Lo}]+)+$
If, though, you are dealing with certain “words” from various RFCs and ISO
standards, these are often specified as containing ASCII only. If so,
you can get by with the literal [A-Z]
idea. It’s just not kind to
impose that restriction if it doesn’t actually exist.
Solution 2 - Regex
Take a look at tchrist's answer, especially if you develop for the web or something more "international".
Oren Trutner's answer isn't quite right (see sample input of "RightHerE" which must be matched, but isn't).
Here is the correct solution:
(?!^.*[A-Z]{2,}.*$)^[A-Za-z]*$
Explained:
(?!^.*[A-Z]{2,}.*$) // don't match the whole expression if there are two or more consecutive uppercase letters
^[A-Za-z]*$ // match uppercase and lowercase letters
/edit
The key for the solution is a negative lookahead. See: Lookahead and Lookbehind Zero-Length Assertions
Solution 3 - Regex
^([A-Z][a-z]+)+$
This looks for sequences of an uppercase letter followed by one or more lowercase letters. Consecutive uppercase letters will not match, as only one is allowed at a time, and it must be followed by a lowercase one.
Solution 4 - Regex
Aside from tchrist's excellent post concerning Unicode, I think you don't need the complex solution with a negative lookahead... Your definition requires an uppercase-letter followed by at least one group of (a lowercase letter optionally followed by an uppercase-letter):
^
[A-Z] // Start with an uppercase Letter
( // A Group of:
[a-z] // mandatory lowercase letter
[A-Z]? // an optional Uppercase Letter at the end
// or in between lowercase letters
)+ // This group at least one time
$
It is just a bit more compact and easier to read, I think...
Solution 5 - Regex
If you want to get all employee names in MySQL which have at least one uppercase letter then apply this query:
SELECT * FROM registration WHERE `name` REGEXP BINARY '[A-Z]';