Regular expression for floating point numbers

Question

I have a task to match floating point numbers. I have written the following regular expression for it:

[-+]?[0-9]*\.?[0-9]*

But, it returns an error:

Invalid escape sequence (valid ones are  \b  \t  \n  \f  \r  \"  \'  \\ )

As per my knowledge, we need to use an escape character for the . also. Please correct me where I am wrong.

Answer 1

I don't think that any of the answers on this page at the time of writing are correct (also many other suggestions elsewhere on SO are wrong too). The complication is that you have to match all of the following possibilities:

• No decimal point (i.e. an integer value)
• Digits both before and after the decimal point (e.g. 0.35 , 22.165)
• Digits before the decimal point only (e.g. 0. , 1234.)
• Digits after the decimal point only (e.g. .0 , .5678)

At the same time, you must ensure that there is at least one digit somewhere, i.e. the following are not allowed:

• a decimal point on its own
• a signed decimal point with no digits (i.e. +. or -.)
• + or - on their own
• an empty string

This seems tricky at first, but one way of finding inspiration is to look at the OpenJDK source for the java.lang.Double.valueOf(String) method (start at http://hg.openjdk.java.net/jdk8/jdk8/jdk, click "browse", navigate down /src/share/classes/java/lang/ and find the Double class). The long regex that this class contains caters for various possibilities that the OP probably didn't have in mind, but ignoring for simplicity the parts of it that deal with NaN, infinity, Hexadecimal notation and exponents, and using \d rather than the POSIX notation for a single digit, I can reduce the important parts of the regex for a signed floating point number with no exponent to:

[+-]?((\d+\.?\d*)|(\.\d+))

I don't think that there is a way of avoiding the (...)|(...) construction without allowing something that contains no digits, or forbidding one of the possibilities that has no digits before the decimal point or no digits after it.

Obviously in practice you will need to cater for trailing or preceding whitespace, either in the regex itself or in the code that uses it.

Answer 2

I want to match what most languages consider valid numbers (integer and floats):

• '5' / '-5'

• '1.0' / '1.' / '.1' / '-1.' / '-.1'

• '0.45326e+04', '666999e-05', '0.2e-3', '-33.e-1'

Notes:

• preceding sign of number ('-' or '+') is optional

• '-1.' and '-.1' are valid but '.' and '-.' are invalid

• '.1e3' is valid, but '.e3' and 'e3' are invalid

In order to support both '1.' and '.1' we need an OR operator ('|') in order to make sure we exclude '.' from matching.

[+-]? +/- sing is optional since ? means 0 or 1 matches

( since we have 2 sub expressions we need to put them in parenthesis

\d+([.]\d*)?(e[+-]?\d+)? This is for numbers starting with a digit

| separates sub expressions

[.]\d+(e[+-]?\d+)? this is for numbers starting with '.'

) end of expressions

• For numbers starting with '.'

[.] first character is dot (inside brackets or else it is a wildcard character)

\d+ one or more digits

(e[+-]?\d+)? this is an optional (0 or 1 matches due to ending '?') scientific notation

• For numbers starting with a digit

\d+ one or more digits

([.]\d*)? optionally we can have a dot character an zero or more digits after it

(e[+-]?\d+)? this is an optional scientific notation

• Scientific notation

e literal that specifies exponent

[+-]? optional exponent sign

\d+ one or more digits

All of those combined:

[+-]?(\d+([.]\d*)?(e[+-]?\d+)?|[.]\d+(e[+-]?\d+)?)

To accept E as well:

[+-]?(\d+([.]\d*)?([eE][+-]?\d+)?|[.]\d+([eE][+-]?\d+)?)

(Test cases)

Answer 3

This is simple: you have used Java and you ought to use \\. instead of \. (search for character escaping in Java).

Answer 4

what you need is:

[\-\+]?[0-9]*(\.[0-9]+)?

I escaped the "+" and "-" sign and also grouped the decimal with its following digits since something like "1." is not a valid number.

The changes will allow you to match integers and floats. for example:

0
+1
-2.0
2.23442

Answer 5

This one worked for me:

(?P<value>[-+]*\d+\.\d+|[-+]*\d+)

You can also use this one (without named parameter):

([-+]*\d+\.\d+|[-+]*\d+)

Use some online regex tester to test it (e.g. regex101 )

Answer 6

^[+-]?([0-9]{1,})[.,]([0-9]{1,})$

This will match:

1. 1.2
2. 12.3
3. 123.4
4. 1,2
5. 12,3
6. 123,4

Answer 7

for javascript

const test = new RegExp('^[+]?([0-9]{0,})*[.]?([0-9]{0,2})?$','g');

Which would work for 1.23 1234.22 0 0.12 12

You can change the parts in the {} to get different results in decimal length and front of the decimal as well. This is used in inputs for entering in number and checking every input as you type only allowing what passes.

Answer 8

This captures floating-point numbers as recognized in C/C++ code:

[+-]?((((\d+\.?\d*)|(\.\d+))([eE][+-]?\d+[fF]?)?)|((\d+\.\d*)|(\.\d+))[fF]?)

• +/- sign
• either only digits, digits., .digits or digits.digits
• optional exponent with e or E, +/- sign and digits
• optional f or F at the end, but only if the number contains a . or an exponent

Answer 9

(\d*)(\.)*(\d+)

This would parse the below.

11.00
12
.0

There must be one number. The decimal point and the number before the decimal point is optional.

Answer 10

[+-]?(([1-9][0-9]*)|(0))([.,][0-9]+)?

[+-]? - optional leading sign

(([1-9][0-9]*)|(0)) - integer without leading zero, including single zero

([.,][0-9]+)? - optional fractional part

Answer 11

[+/-] [0-9]*.[0-9]+

Try this solution.

Answer 12

In C++ using the regex library

The answer would go about like this:

[0-9]?([0-9]*[.])?[0-9]+

Notice that I don't take the sign symbol, if you wanted it with the sign symbol it would go about this:

[+-]?([0-9]*[.])?[0-9]+

This also separates a regular number or a decimal number.

Answer 13

In c notation, float number can occur in following shapes:

1. 123
2. 123.
3. 123.24
4. .24
5. 2e-2 = 2 * 10 pow -2 = 2 * 0.1
6. 4E+4 = 4 * 10 pow 4 = 4 * 10 000

For creating float regular expresion, I will first create "int regular expresion variable":

(([1-9][0-9]*)|0) will be int

Now, I will write small chunks of float regular expresion - solution is to concat those chunks with or simbol "|".

Chunks:

- (([+-]?{int}) satysfies case 1
- (([+-]?{int})"."[0-9]*)  satysfies cases 2 and 3
- ("."[0-9]*) satysfies case 4
- ([+-]?{int}[eE][+-]?{int}) satysfies cases 5 and 6

Final solution (concanating small chunks):

(([+-]?{int})|(([+-]?{int})"."[0-9]*)|("."[0-9]*)|([+-]?{int}[eE][+-]?{int})

Answer 14

For those who searching a regex which would validate an entire input that should be a signed float point number on every single character typed by a user.

I.e. a sign goes first (should match and be valid), then all the digits (still match and valid) and its optional decimal part.

In JS, we use onkeydown/oninput event to do that + the following regex:

^[+-]?[0-9]*([\.][0-9]*)?$

Answer 15

In C Language, the answer would go about like this:

[+-]?((\d+\.?\d*)|(\.\d+))(([eE][+-]?)?\d+)?[fFlL]?

Answer 16

Match strings which are considered valid representations of floating point values by C and C++ (and many other language) compilers, using the C++ regex library:

In C++ with #include <regex> you can do this:

std::regex r("[+-]?[0-9]+[.][0-9]*([e][+-]?[0-9]+)?");
return std::regex_match(value, r);

which is considerably more simple than most of the above C++ related answers.

It matches strings which are considered to be valid string representations of floating point numbers according to C++ compilers.

That means things like

1.
-1.

are considered valid representations of floating point numbers but that

.1
-.1

are not.

To explain the expression in more detail, it is essentially composed of two parts:

[+-]?[0-9]+[.][0-9]*([e][+-]?[0-9]+)?

[+-]?[0-9]+[.][0-9]*
and                 ([e][+-]?[0-9]+)?

The first part is easy to understand:

• Optional (meaning 0 or 1 occurances of) '+' or '-' character
• At least 1 digit, or more than one digit
• A literal '.' character, which is mandatory (otherwise you have a representation of an integer not a floating point value)
• If you want the '.' to be optional, change it to [.]?
• Followed by zero or more digits

The second part is also quite easy once broken down.

• Firstly note that the expression is contained in parenthesys, followed by a ?. This means the expression inside the parentesys must match 0 or 1 times. (Meaning it is optional.)
• Inside we have a literal 'e' character which must match
• Followed by an optional '+' or '-' character
• Followed by 1 or more digits

The last part [+-]?[0-9]+ is a regex for matching an integer.

To match integer values as well use:

[+-]?[0-9]+[.]?[0-9]*([e][+-]?[0-9]+)?

Note the ? after the [.].

But be aware this will also match things like

+100e+100

which is perhaps an unusual representation of an integer. Although it is technically an integer, you probably wouldn't expect this to be a match.

Other answers provide a solution if you don't want this behaviour.

To ensure an entire string is a match rather than just a string containing a match use anchors:

"^[+-]?[0-9]+[.][0-9]*([e][+-]?[0-9]+)?$"

Examples

Without anchor characters

With anchor characters

With optional '.' character:

Note that this matches the string .-100 and .1e100 if you do not include the anchor characters, which may not be what you want.

When considering this problem:

My aim was to validate user input to ensure it matches a valid C++ string representation of a floating point number. Hence I am assuming you will use anchor characters and that you do not consider strings like

hello world 3.14 this contains a floating point number

to be a valid floating point number - because although the string contains a floating point number, the whole string is not a valid floating point number.

Other answers may suit your needs better if you just want to detect floating points within larger strings/text.

Answer 17

This is for javascript (idk if there's a large difference between languages)

`int: /0|[1-9][0-9]*/`

For floats:

`float:   /[0-9]+\.[0-9]+/`

Answer 18

if you are using flutter you can use [0-9]([.]([0-9])*)? This would parse 123.123