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

Quelle est l'expression régulière d'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.

Les jetons d'expression régulière valides varient selon l'implémentation. Un formulaire générique est:

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

Plus compact:

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

Les deux supposent que les deux ont au moins un chiffre avant et un après la décimale.

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

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

Pour faire correspondre les nombres sans premier chiffre avant les nombres décimaux ( .12) et entiers ayant une période de fin ( 12.) tout en excluant la saisie d'une seule période ( .), essayez ce qui suit:

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

Ajoutée

Enveloppé la portion fractionnée ()?pour la rendre facultative. Sachez que cela exclut des formes telles que l' 12. inclusion qui ressemblerait davantage ^\d+\\.?\d{0,2}$.

Ajoutée

Permet ^\d{1,6}(\.\d{1,2})?$d'arrêter la répétition et de restreindre une partie entière de la valeur décimale.

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

Et comme les expressions régulières sont horribles à lire, et encore moins comprises, voici l'équivalent détaillé:

^                         # 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 le remplacer [0-9]par \ddans la plupart des implémentations d'expressions régulières (y compris PCRE , la plus courante). Je l'ai laissé [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

Pour inclure un signe moins facultatif et pour interdire des nombres comme 015(qui peuvent être confondus avec des nombres octaux), écrivez:

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

Pour les nombres qui n'ont pas de séparateur de milliers, j'aime cette expression régulière simple et compacte:

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

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

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

Ce dernier correspond à
1
100
100.
100,74
100,7
0,7
0,7
0,72

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

J'utilise celui-ci pour 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

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

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

Essaye ça

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

Cela permettra également des signes positifs et négatifs.

La réponse principale est FAUX car elle valide 5.ou 5,saisit

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 => "

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

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

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

Ne vous devez prendre een e666.76compte?

Avec

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

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

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


alert(getInteger('-11.11'));

Cela a fonctionné avec moi:

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

Le groupe 1 est votre nombre flottant et le groupe 2 est la fraction uniquement.

J'en ai essayé un avec mon projet. Cela permet également aux numéros avec des + | -signes.

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

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

Cela permettra décimal avec exponentiation et jusqu'à 2 chiffres,

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

Démo

 function DecimalNumberValidation() {
        var amounttext = ;
            if (!(/^[-+]?\d*\.?\d*$/.test(document.getElementById('txtRemittanceNumber').value))){
            alert('Please enter only numbers into amount textbox.')
            }
            else
            {
            alert('Right Number');
            }
    }

La fonction validera n'importe quel nombre décimal. Le numéro météorologique a des décimales ou non, il dira "Numéro correct" autrement "Veuillez entrer uniquement les nombres dans la zone de texte du montant." un message d'alerte apparaîtra.

Merci... :)