I want a regular expression that will accept only floating point numbers from 0 to 9 and minus sign.
Please help.
^[-+]?[0-9]*\.?[0-9]+$
^ - start of string
[-+]? - 0 or 1 sign indicator
[0-9]* - 0 or more integers
\. - the character . (. is used in regex to mean "any character")
[0-9]+ - 1 or more integers
$ - the end of the string
If you are instead using the comma as a decimal seperator, use , instead of \.
If you are using both/either, you can use [.,]
Try ^[-+]?[0-9]*[.,]?[0-9]+$.
This regular expression will match an optional sign, that is either followed by zero or more digits followed by a dot and one or more digits (a floating point number with optional integer part), or followed by one or more digits (an integer).
Source: http://www.regular-expressions.info/floatingpoint.html - altered to work with commas as decimal separator
Related
I'm trying to find a regex for numeric inputs. We can receive a leading 0 just if we add a dot for adding 1 or 2 decimal numbers. And of course just accept numbers.
These are the scenarios that we can accept:
0.01
1.1
1.02
120.01
We can't accept these values
0023
0100
.01
.12
Which regex is the best option for these cases?
Until now we try we the following regex for accepting just number and dots
[A-Za-z,]
And also we try with the following ones:
^[+-]?[0-9]{1,3}(?:[0-9]*(?:[.,][0-9]{1})?|(?:,[0-9]{3})*(?:\.[0-9]{1,2})?|(?:\.[0-9]{3})*(?:,[0-9]{1,2})?)$
"/^[-]?[$]\d{1,3}(?:,?\d{3})*\.\d{2}$/"
"/(^(\d{1})\.{0,1}([0-9]){0,2}$)|(^([1-9])\d{0,2}(\,\d{0,3})$)/g"
(?:0|[1-9][0-9]*)(?:\.[0-9]{1,2})?
And the next one for deleting the leading zeros but it didn't work for 0.10 cases
^0+
If a negative lookahead is supported, you can exclude matches that start with a zero and have no decimal part.
^(?!0\d*$)\d+(?:\.\d{1,2})?$
^ Start of string
(?!0+\d*$) Negative lookahead, assert not a zero followed by optional digits at the right
\d+ Match 1+ digits
(?:\.\d{1,2})? Match an optional decimal part with 1 or 2 digits
$ End of string
Regex demo
I would go with ^(0|[1-9]\d*|(0|[1-9]\d*)\.\d+)$
You can test here: https://regex101.com/r/oNMgR9/1
Explanation
^ means : match the beginning of the string (or line if the m flag is enabled).
$ means : match the end of the string (or line if the m flag is enabled).
(a|b) means match "a" or match "b" so I'll use this to match either "0" alone or any number not starting with a "0". It's the syntax for a logical or.
. alone is used to match any char. So you have to escape it if you want to match the dot character. This is why I wrote 0\. instead of 0..
[ ] is used to list some characters you want to match. It can be a range if you use the - char, so [1-9] means any digit char from "1" to "9".
\d is to match a digit. It's totally equivalent to [0-9].
* means : match the preceding pattern 0 or many times, so \d* means that it will match 0 or many times a digit, so it will match "8" or "465" or "09" but also an empty string "". If you want to match the preceding pattern at least once or many times then you use + instead of *. So \d+ won't match an empty string "" but \d* would match it.
A) Just a number not starting with 0
[1-9]\d* will match any digit from 1 to 9 and then optionnaly followed by other digits. This will match numbers without a decimal point.
B) Just 0
0 alone is a possibility. This is because the case above isn't covering it.
B) A number with decimals
(0|[1-9]\d*)\.\d+ will match either a "0" alone or a number not starting by "0" and then followed by a point and some other digits (which have to be present because we don't want to match "45." without the numbers behind the dot).
Better alternative
The solution from #TheFourthBird is a bit cleaner with the use of a negative lookahead. It's just a bit different to understand. And he read the question completely: You wanted 1 or 2 digits after the decimal. I forgot about that, so, effectively, \d+ should be replaced by \d{1,2} as you don't want more than 2 digits.
You can use
^(?![0.]+$)(?:[1-9]\d*|0)(?:\.\d{1,2})?$
See the regex demo.
Details:
^ - start of string
(?![0.]+$) - fail the match if there are just zeros or dots till end of string
(?:[1-9]\d*|0) - either a non-zero digit followed with any zero or more digits or a zero
(?:\.\d{1,2})? - optionally followed with a sequence of a . and one or two digits
$ - end of string.
I want to write a regular expression that must take a valid only the numerical values with 0, 1 or 2 digits after the decimal point.
So I tried to do it like: "^\\d+(\\.\\d){0,2}$" but it returns true even for numbers with 3 digits after the decimal point.
Any ideas what's wrong?
Your regex ^\d+(\.\d){0,2}$ matches 1 or 1.0 but also 1.0.0 because you specifiy a quantifier for 0-2 times for the group (\.\d){0,2} and would not match 3 digits after the dot.
To match a digit which could be followed by a dot and 1 or 2 digits after the dot you could use:
^\d+(?:\.\d{1,2})?$
Here the group after the first digit(s) is optional (?:\.\d{1,2})? and the quantifier is specified for the digit \d{1,2}.
Your regex is saying "some digits, followed by 0-2 occurrences of a dot followed by a digit". Spot the mistake? 3.1.4 would match, but 3.14 wouldn't. Contrary to what you state in the question, 3 digits after the point wouldn't match either.
Instead, you would need something like this, assuming that the fractional part should be optional:
\d+(\.\d{0,2})?
Or, anchored and escaped for a string in your language of choice:
"^\\d+(\\.\\d{0,2})$"
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.
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.
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.
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.
I need a regular expression that validates a number, but doesn't require a digit after the decimal.
ie.
123
123.
123.4
would all be valid
123..
would be invalid
Any would be greatly appreciated!
Use the following:
/^\d*\.?\d*$/
^ - Beginning of the line;
\d* - 0 or more digits;
\.? - An optional dot (escaped, because in regex, . is a special character);
\d* - 0 or more digits (the decimal part);
$ - End of the line.
This allows for .5 decimal rather than requiring the leading zero, such as 0.5
/\d+\.?\d*/
One or more digits (\d+), optional period (\.?), zero or more digits (\d*).
Depending on your usage or regex engine you may need to add start/end line anchors:
/^\d+\.?\d*$/
Debuggex Demo
You need a regular expression like the following to do it properly:
/^[+-]?((\d+(\.\d*)?)|(\.\d+))$/
The same expression with whitespace, using the extended modifier (as supported by Perl):
/^ [+-]? ( (\d+ (\.\d*)?) | (\.\d+) ) $/x
or with comments:
/^ # Beginning of string
[+-]? # Optional plus or minus character
( # Followed by either:
( # Start of first option
\d+ # One or more digits
(\.\d*)? # Optionally followed by: one decimal point and zero or more digits
) # End of first option
| # or
(\.\d+) # One decimal point followed by one or more digits
) # End of grouping of the OR options
$ # End of string (i.e. no extra characters remaining)
/x # Extended modifier (allows whitespace & comments in regular expression)
For example, it will match:
123
23.45
34.
.45
-123
-273.15
-42.
-.45
+516
+9.8
+2.
+.5
And will reject these non-numbers:
. (single decimal point)
-. (negative decimal point)
+. (plus decimal point)
(empty string)
The simpler solutions can incorrectly reject valid numbers or match these non-numbers.
this matches all requirements:
^\d+(\.\d+)?$
Try this regex:
\d+\.?\d*
\d+ digits before optional decimal
.? optional decimal(optional due to the ? quantifier)
\d* optional digits after decimal
I ended up using the following:
^\d*\.?\d+$
This makes the following invalid:
.
3.
This is what I did. It's more strict than any of the above (and more correct than some):
^0$|^[1-9]\d*$|^\.\d+$|^0\.\d*$|^[1-9]\d*\.\d*$
Strings that passes:
0
0.
1
123
123.
123.4
.0
.0123
.123
0.123
1.234
12.34
Strings that fails:
.
00000
01
.0.
..
00.123
02.134
you can use this:
^\d+(\.\d)?\d*$
matches:
11
11.1
0.2
does not match:
.2
2.
2.6.9
^[+-]?(([1-9][0-9]*)?[0-9](\.[0-9]*)?|\.[0-9]+)$
should reflect what people usually think of as a well formed decimal number.
The digits before the decimal point can be either a single digit, in which case it can be from 0 to 9, or more than one digits, in which case it cannot start with a 0.
If there are any digits present before the decimal sign, then the decimal and the digits following it are optional. Otherwise, a decimal has to be present followed by at least one digit. Note that multiple trailing 0's are allowed after the decimal point.
grep -E '^[+-]?(([1-9][0-9]*)?[0-9](\.[0-9]*)?|\.[0-9]+)$'
correctly matches the following:
9
0
10
10.
0.
0.0
0.100
0.10
0.01
10.0
10.10
.0
.1
.00
.100
.001
as well as their signed equivalents, whereas it rejects the following:
.
00
01
00.0
01.3
and their signed equivalents, as well as the empty string.
What language? In Perl style: ^\d+(\.\d*)?$
What you asked is already answered so this is just an additional info for those who want only 2 decimal digits if optional decimal point is entered:
^\d+(\.\d{2})?$
^ : start of the string
\d : a digit (equal to [0-9])
+ : one and unlimited times
Capturing Group (.\d{2})?
? : zero and one times
. : character .
\d : a digit (equal to [0-9])
{2} : exactly 2 times
$ : end of the string
1 : match
123 : match
123.00 : match
123. : no match
123.. : no match
123.0 : no match
123.000 : no match
123.00.00 : no match
try this. ^[0-9]\d{0,9}(\.\d{1,3})?%?$ it is tested and worked for me.
Regular expression:
^\d+((.)|(.\d{0,1})?)$
use \d+ instead of \d{0,1} if you want to allow more then one number use \d{0,2} instead of \d{0,1} if you want to allow up to two numbers after coma. See the example below for reference:
or
^\d+((.)|(.\d{0,2})?)$
or
^\d+((.)|(.\d+)?)$
Explanation
(These are generated by regex101)
^ asserts position at start of a line
\d matches a digit (equivalent to [0-9])
+ matches the previous token between one and unlimited times, as many times as possible, giving back as needed (greedy)
1st Capturing Group ((.)|(.\d{0,1})?)
1st Alternative (.)
2nd Capturing Group (.)
. matches any character (except for line terminators)
2nd Alternative (.\d{0,1})?
3rd Capturing Group (.\d{0,1})?
? matches the previous token between zero and one times, as many times as possible, giving back as needed (greedy)
. matches any character (except for line terminators)
\d matches a digit (equivalent to [0-9])
{0,1} matches the previous token between zero and one times, as many times as possible, giving back as needed (greedy)
$ asserts position at the end of a line
Sandbox
Play with regex here: https://regex101.com/
(?<![^d])\d+(?:\.\d+)?(?![^d])
clean and simple.
This uses Suffix and Prefix, RegEx features.
It directly returns true - false for IsMatch condition
^\d+(()|(\.\d+)?)$
Came up with this. Allows both integer and decimal, but forces a complete decimal (leading and trailing numbers) if you decide to enter a decimal.
In Perl, use Regexp::Common which will allow you to assemble a finely-tuned regular expression for your particular number format. If you are not using Perl, the generated regular expression can still typically be used by other languages.
Printing the result of generating the example regular expressions in Regexp::Common::Number:
$ perl -MRegexp::Common=number -E 'say $RE{num}{int}'
(?:(?:[-+]?)(?:[0123456789]+))
$ perl -MRegexp::Common=number -E 'say $RE{num}{real}'
(?:(?i)(?:[-+]?)(?:(?=[.]?[0123456789])(?:[0123456789]*)(?:(?:[.])(?:[0123456789]{0,}))?)(?:(?:[E])(?:(?:[-+]?)(?:[0123456789]+))|))
$ perl -MRegexp::Common=number -E 'say $RE{num}{real}{-base=>16}'
(?:(?i)(?:[-+]?)(?:(?=[.]?[0123456789ABCDEF])(?:[0123456789ABCDEF]*)(?:(?:[.])(?:[0123456789ABCDEF]{0,}))?)(?:(?:[G])(?:(?:[-+]?)(?:[0123456789ABCDEF]+))|))
For those who wanna match the same thing as JavaScript does:
[-+]?(\d+\.?\d*|\.\d+)
Matches:
1
+1
-1
0.1
-1.
.1
+.1
Drawing: https://regexper.com/#%5B-%2B%5D%3F%28%5Cd%2B%5C.%3F%5Cd*%7C%5C.%5Cd%2B%29
I'm looking for a regular expression which whill validate the number starting from 0 up - and might include decimals.
Any idea?
A simple regex to validate a number:
^\d+(\.\d+)?$
This should work for a number with optional leading zeros, with an optional single dot and more digits.
^...$ - match from start to end of the string (will not validate ab12.4c)
\d+ - At least one digit.
(...)? - optional group of...
\.\d+ - literal dot and one or more digits.
Because decimal numbers may or may not have a decimal point in them, and may or may not have digits before that decimal point if they have some afterwards, and may or may not have digits following that decimal point if they have some before it, you must use this:
^(\d+(\.\d*)?|\d*\.\d+)$
which is usually better written:
^(?:\d+(?:\.\d*)?|\d*\.\d+)$
and much better written:
(?x)
^ # anchor to start of string
(?: # EITHER
\d+ (?: \. \d* )? # some digits, then optionally a decimal point following by optional digits
| # OR ELSE
\d* \. \d+ # optional digits followed then a decimal point and more digits
) # END ALTERNATIVES
$ # anchor to end of string
If your regex compiler doesn’t support \d, or also depending on how Unicode-aware your regex engine is if you should prefer to match only ASCII digits instead of anything with the Unicode Decimal_Number property (shortcut Nd) — that is, anything with the Numeric_Type=Decimal property — then you might wish to swap in [0-9] for all instances above where I’ve used \d.
I always use RegExr to build my regular expressions. It is sort of drag-and-drop and has a live-preview of your regex and the result.
It'll look something like ^0[,.0-9]*
^[0-9]+(\.[0-9]+)?$
Note that with this expression 0.1 will be valid but .1 won't.
This should do what you want:
^[0-9]+([,.][0-9]+)?$
It will match any number starting with 0 and then any number, maybe a , or . and any number
'/^([0-9\.]+)$/'
will match if the test string is a positive decimal number