web-dev-qa-db-fra.com

Expression régulière simple pour une virgule avec une précision de 2

Quelle est l'expression régulière pour une décimale avec une précision de 2?

Exemples valides :

123.12
2
56754
92929292929292.12
0.21
3.1

Exemples non valides: 

12.1232
2.23332
e666.76

Le point décimal peut être facultatif et des nombres entiers peuvent également être inclus.

regex
242
user39221

Les jetons de regex valides varient en fonction de l'implémentation. La forme la plus générique que je connaisse serait:

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

Le plus compact:

\d+(\.\d{1,2})?

Les deux supposent que vous devez avoir au moins un chiffre avant et un après la décimale.

Pour exiger que la chaîne entière soit un numéro de ce formulaire, placez l'expression dans des balises de début et de fin telles que (dans le formulaire Perl):

^\d+(\.\d{1,2})?$

AJOUTÉ: Enveloppé la fraction dans ()? pour le rendre facultatif. Sachez que cela exclut les formulaires tels que "12." Y compris, ce serait plus comme ^\d+\.?\d{0,2}$.

Ajouté: Utilisez ce format ^\d{1,6}(\.\d{1,2})?$ pour arrêter la répétition et donner une restriction à la partie entière de la valeur décimale.

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

Et puisque les expressions régulières sont horribles à lire, et encore moins à comprendre, voici l'équivalent verbal:

^                         # Start of string
 [0-9]+                   # Require one or more numbers
       (                  # Begin optional group
        \.                # Point must be escaped or it is treated as "any character"
          [0-9]{1,2}      # One or two numbers
                    )?    # End group--signify that it's optional with "?"
                      $   # End of string

Vous pouvez remplacer [0-9] par \d dans la plupart des implémentations d'expressions régulières (y compris PCRE , la plus courante). Je l'ai laissé en tant que [0-9] car je pense que c'est plus facile à lire.

En outre, voici le script Python simple que j'ai utilisé pour le vérifier:

import re
deci_num_checker = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")

valid = ["123.12", "2", "56754", "92929292929292.12", "0.21", "3.1"]
invalid = ["12.1232", "2.23332", "e666.76"]

assert len([deci_num_checker.match(x) != None for x in valid]) == len(valid)
assert [deci_num_checker.match(x) == None for x in invalid].count(False) == 0
246
dbr

Pour inclure un signe moins facultatif et interdire les nombres tels que 015 (qui peut être confondu avec des nombres octaux), écrivez:

-?(0|([1-9]\d*))(\.\d+)?
18
Karol Bienkowski

Pour les nombres qui n'ont pas de séparateur de milliers, j'aime bien cette regex simple et compacte:

\d+(\.\d{2})?|\.\d{2}

ou, pour ne pas se limiter à une précision de 2:

\d+(\.\d*)?|\.\d+

Les derniers matchs
1
100
100.
100,74
100,7
0,7
.7
. 72

Et cela ne correspond pas à une chaîne vide (comme\d *.?\D * le ferait)

13
Jimmy

J'utilise celui-ci jusqu'à deux décimales:
(^(\+|\-)(0|([1-9][0-9]*))(\.[0-9]{1,2})?$)|(^(0{0,1}|([1-9][0-9]*))(\.[0-9]{1,2})?$) passe:
. 25
0,25
10,25
+ 0,25

ne passe pas:
- 25
01.25
1.
1,256

7
frustrated regex user
^[0-9]+(\.([0-9]{1,2})?)?$

Fera des choses comme 12. accepté. Ce n’est pas ce qui est communément accepté, mais si vous avez besoin d’être «flexible», c’est une solution. Et bien sûr, [0-9] peut être remplacé par \d, mais je suppose qu’il est plus lisible de cette façon.

7
BSharper

Essaye ça

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

Cela permettra aussi des signes positifs et négatifs.

5
Android

En général, c'est-à-dire des décimales illimitées:

^-?(([1-9]\d*)|0)(.0*[1-9](0*[1-9])*)?$.

2
SK9
preg_match("/^-?\d+[\.]?\d\d$/", $sum)
2
DEC32

en ajoutant ma réponse aussi, quelqu'un pourrait la trouver utile ou pourrait être la mienne correcte aussi.

function getInteger(int){
  var regx = /^[-+]?[\d.]+$/g;
  return regx.test(int);
}


alert(getInteger('-11.11'));
1
STEEL

Ne devrez-vous pas prendre en compte la e dans e666.76?

Avec

(e|0-9)\d*\d.\d{1,2)
1
spacemonkeys

J'en ai essayé un avec mon projet . Cela permet également les nombres avec des signes + | -.

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

Cela a fonctionné avec moi:

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

Groupe 1 est le numéro de votre float et groupe 2 est la fraction uniquement.

1
shady sherif

Chrome 56 n'accepte pas ce type de modèle (Chrome 56 accepte 11.11. Un supplémentaire.) Avec le numéro de type, utilisez le type comme texte comme progrès.

0
rajesh_kw

Cela permettra une décimale avec une exponentiation et jusqu’à 2 chiffres, 

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

Démo

0
RAN_0915

Réponse principale valide les entrées 5. ou 5,

ce code le gère (mais dans mon exemple, les nombres négatifs sont interdits): 

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

les résultats sont ci-dessous:

true => "0"/true => "0.00"/true => "0.0"/true => "0,00"/true => "0,0"/true => "1,2" true => "1.1"/true => "1"/true => "100" true => "100.00"/true => "100.0"/true => "1.11"/true => "1,11"/false => "-5"/false => "-0.00"/true => "101"/false => "0.00.0"/true => "0.000"/true => "000.25"/false => ".25"/true => "100.01" / true => "100.2"/true => "00"/false => "5."/false => "6"/true => "82"/true => "81,3"/true => "7"/true => "7.654"

0
Vivien Pipo