Regex that does not allow zeros - regex

Question

I use this regex:
/^(?!0000)(?!0+(?:[.,]\d{1,2})?$)\d{1,4}(?:[.,]\d{1,2})?$/
It allows decimal numbers (. and , separators), with two digits after the separator. It does not allow zero values. What I want to do is to make it allow numbers like 0.1 and 0.09 etc... Here it's impossible to write any number starting with 0. I don't know how to do this. Any idea?
Thanks.

Answer 1

You can simplify your regex with just one negative lookahead:
/^(?![,.0]*$)\d{1,4}(?:[.,]\d{1,2})?$/gm
RegEx Demo
(?![,.0]*$) will prevent any input with just 0s, dots or commas in input.

Answer 2

Any regex based approach would be trivial to bypass. For example, they could use any of the following to evade your regex filter:
+0- Start with +
-0 - Start with -
0e0 - Scientific notation
1e-999 - Not real 0, but most likely will be one after conversion.
And any combination of methods above.
Long story short: regex wouldn't work here.
Try to cast your string to a number and reject if it equals to 0.
You should be able to do that in most languages, including JavaScript.

Answer 3

Since you mentioned JS/Angular, you may replace all , with . (in case the decimal separator is ,) and cast the string to a number to check if it is zero, and if it is, then use your simplified regex /^\d{1,4}(?:[.,]\d{1,2})?$/ that makes sure there are 1 to 4 digits in the whole part and 1 to 2 digits in the fractional part:
function check(str) {
str = str.replace(/,/g, ".");
if ( parseFloat(str) > 0 ) {
return /^\d{1,4}(?:\.\d{1,2})?$/.test(str);
}
return false;
}
console.log(check("0,00"));
console.log(check("0,09"));
console.log(check("900000"));
If you cannot access the code, adjust the negative lookahead like
^(?!0+(?:[.,]0+)?$)\d{1,4}(?:[.,]\d{1,2})?$
See the regex demo
The (?!0+(?:[.,]0+)?$) negative lookahead fails the match only if the string starts with 1 or more zeros, and then has an optional sequence of , or . followed with 1 or more zeros.
^ - start of a string
(?!0+(?:[.,]0+)?$) - reject the match if it matches a sequence of
0+ - 1 or more zeros
(?:[.,]0+)? - an optional sequence of . or , followed with 1 or more zeros
\d{1,4} - 1 to 4 digits
(?:[.,]\d{1,2})? - an optional sequence of:
[.,] - a . or ,
\d{1,2} - any 1 or 2 digits
$ - end of string.
The lookahead pattern may be reduced to (?!0*[.,]?0+$), since the consuming pattern will ensure the correct format is matched.