I need regex to validate a number that could contain thousand separators or decimals using javascript.
Max value being `9,999,999.99`

Min value `0.01`

Other valid values:
`11,111`

`11.1`

`1,111.11`

INVALID values:
`1111`

`1111,11`

`,111`

`111,`

I've searched all over with no joy.

Tezra's formula fails for '1.' or '1.0'. For my purposes, I allow leading and trailing zeros, as well as a leading + or - sign, like so:

```
^[-+]?((\d{1,3}(,\d{3})*)|(\d*))(\.|\.\d*)?$
```

In a recent project we needed to alter this version in order to meet international requirements.
This is what we used: `^-?(\d{1,3}(?<tt>\.|\,| ))((\d{3}\k<tt>)*(\d{3}(?!\k<tt>)[\.|\,]))?\d*$`

Creating a named group `(?<tt>\.|\,| )`

allowed us to use the negative look ahead `(?!\k<tt>)[\.|\,])`

later to ensure the thousands separator and the decimal point are in fact different.

First, I want to point out that if you own the form the data is coming from, the best way to restrict the input is to use the proper form elements (aka, number field)

```
<input type="number" name="size" min="0.01" max="9,999,999.99" step="0.01">
```

Whether "," can be entered will be based on the browser, but the browser will always give you the value as an actual number. (Remember that all form data must be validated/sanitized server side as well. Never trust the client)

Second, I'd like to expand on the other answers to a more robust (platform independent)/modifiable regex.

- You should surround the regex with ^ and $ to make sure you are matching against the whole number, not just a subset of it. ex
`^<my_regex>$`

- The right side of the decimal is optional, so we can put it in an optional group
`(<regex>)?`

- Matching a literal period and than any chain of numbers is simply
`\.\d+`

- If you want to insist the last number after the decimal isn't a 0, you can use
`[1-9]`

for "a non-zero number" so`\.\d+[1-9]`

- If you want to insist the last number after the decimal isn't a 0, you can use
- For the left side of the decimal, the leading number will be non-zero, or the number is zero. So
`([1-9]<rest-of-number-regex>|0)`

- The first group of numbers will be 1-3 digits so
`[1-9]\d{0,2}`

- After that, we have to add digits in 3s so
`(,\d{3})*`

- Remember ? means optional, so to make the , optional is just
`(,?\d{3})*`

- Remember ? means optional, so to make the , optional is just

Putting it all together

```
^([1-9]\d{0,2}(,?\d{3})*|0)(\.\d+[1-9])?$
```

```
/^\d{1,3}(,\d{3})*(\.\d+)?$/
```

About the minimum and maximum values... Well, I wouldn't do it with a regex, but you can add lookaheads at the beginning:

```
/^(?!0+\.00)(?=.{1,9}(\.|$))\d{1,3}(,\d{3})*(\.\d+)?$/
```

Note: this allows `0,999.00`

, so you may want to change it to:

```
/^(?!0+\.00)(?=.{1,9}(\.|$))(?!0(?!\.))\d{1,3}(,\d{3})*(\.\d+)?$/
```

which would not allow a leading 0.

**Edit:**

Tests: http://jsfiddle.net/pKsYq/2/

```
((\d){1,3})+([,][\d]{3})*([.](\d)*)?
```

It worked on a few, but I'm still learning regex as well.

The logic should be 1-3 digits 0-1 times, 1 comma followed by 3 digits any number of times, and a single . followed by any number of digits 0-1 times

I have used below regrex for following retrictions -

```
^(?!0|\.00)[0-9]+(,\d{3})*(.[0-9]{0,2})$
```

- Not allow 0 and .00.
- ','(thousand seperator) after 3 digits.
- '.' (decimal upto 2 decimal places).

©2020 All rights reserved.