interesting Regular Expression - php

Question

Hi very interesting Regex Expression, i tried a lot of time,but some difficulties in it.
Regex rule:
user can use following characters all small([a-z]), all capital([A-Z]), numbers([0-9]) and the follownig symbols
!~*:;<>+#-£$&_?(){}[] and one space. All characers are in any order,
but restiriction are following:
input can not start with digit.
user can use zero or one white space any where in the input, but input can not start and end with white space.
input must contains at least one special following character!~*:;<>+#-£$&_?(){}[] in any order.
input length is in between 6-15.
Question: Regular expression which fullfills the above requirment. i have spent many of hours on it.but make the following Regex expression.
Regex='/^([a-zA-Z]|!|\~|*|\:|\;|\<|>|+|#|-|\£|\$|\&|_|\?|{|}|[|]|(|)){1,20}(\s){0,1}([a-zA-Z]|!|\~|*|\:|\;|\<|>|+|#|-|\d|\£|\$|\&|_|\?|{|}|[|]|(|)){1,20}(!|\~|*|\:|\;|\<|>|+|#|-|\£|\$|\&|_|\?|{|}|[|]|(|)){1,}$/i';
it fullfills all rule but not rule no.4.
complete regex which fullfills the above rules will be appreciated.

Answer 1

Some hints before getting to the solution.
You use the modifier i, means "case independent" matching. So no a-zA-Z needed just use a-z or A-Z.
From your list of characters [a-zA-Z]|!|\~|*|\:|\;|\<|>|+|#|-|\£|\$|\&|_|\?|{|}|[|]|(|)
There are some characters that needs escaping, since they are special in regex.
Skip the alternation and put all characters in the char class (you can also spare the escaping then)
To enforce some of your rules you need lookahead assertions
So your regex (for php) can look like:
^(?![\d ])(?![^ ]*[ ][^ ]*[ ])(?=.*[!~*:;<>+#\-£$&_?{}\[\]()])[a-z\d!~*:;<>+#\-£$&_?{}\[\]() ]{6,15}(?<![ ])$
If you need the regex for JavaScript, you can not use the lookbehind assertion. You can replace it also by a lookahead:
^(?![\d ])(?!.* $)(?![^ ]*[ ][^ ]*[ ])(?=.*[!~*:;<>+#\-£$&_?{}\[\]()])[a-z\d!~*:;<>+#\-£$&_?{}\[\]() ]{6,15}$
See it here on Regexr (Note. I have used there [^ \r]) just because I need multiline for testing)
The regex explained:
[a-z\d!~*:;<>+#\-£$&_?{}\[\]() ]{6,15} matches all characters you want to allow, in the required length.
(?![\d ]) negative lookahead assertion, that ensures the string does not start with a digit or a space.
(?![^ ]*[ ][^ ]*[ ]) negative lookahead assertion, that ensures the string does not have more than one space
(?=.*[!~*:;<>+#\-£$&_?{}\[\]()]) positive lookahead assertion, that ensures the string does have one of your special symbols
(?<![ ])$ negative lookbehind assertion, that ensures the string does not end with a space.
Unicode:
JavaScript does not support this natively!
If you want to support Unicode letters instead of only the old ASCII letters, then replace
[a-z] with \p{L}. You can then also remove the i modifier, since \p{L} is a Unicode property that matches all letters in any language (only complete letters, not combined ones, there you could use [\p{L}\p{Mn}\p{Mc}])

Answer 2

Here's how I'd do it.
<?php
$symbols = '!~*:;<>+#\-£$&_?(){}\[\]';
$regex = "/^(?=.*[$symbols])(?=.{6,15}\$)(?!.* )[a-zA-Z][a-zA-Z0-9 $symbols]+[a-zA-Z0-9]$";
?>
If any of the following explanations are unclear, please ask, referring to their number:
Note that we've factored out the list of symbols for convenience.
Note that we've escaped -, [, and ], as these are meaningful characters in character classes. It's possible to not escape them as long as the - is at the beginning or end, and the ] is at the beginning, but since we're mixing $symbols with other characters, we can't be sure where the "beginning" or "end" really is.
(?=...) are known as lookaheads. They're useful for asserting multiple conditions. For example, the (?=.*[$symbols]) asserts that there is a symbol somewhere (hence the .*); and the (?=.{6,15}\$) asserts that, from beginning to end, the string is between 6 and 15 characters in length (note that the $ is escaped only because it exists in a double-quote).
The (?!...) is known as a negative lookahead. The (?!.* ) asserts that there are no two consecutive spaces anywhere.
The remainder should be obvious.

Answer 3

Like suggested by #Juhana in the comments, why not test your rules separately rather than make a single over complex regex? something like this. (these are not actual solutions or tested as you didn't provide any test strings, more an example of how to think differently about your problem)
Javascript
function verify(string) {
var length = string.length;
if (length < 6 || length > 15 || /^\d/.test(string) || /^\s/.test(string) || /\s$/.test(string) || /\s\s/.test(string) || /[!~*:;<>+#-£$&_?(){}[\]]+/.test(string)) {
return false;
}
return true;
}
PHP
function verify($string) {
$length = strlen($string);
if ($length < 6 || $length > 15 || preg_match("/^\d/", $string) || preg_match("/^\s/", $string) || preg_match("/\s$/", $string) || preg_match("/\s\s/", $string) || preg_match("/[!~*:;<>+#-£$&_?(){}[\]]+/", $string)) {
return false;
}
return true;
}