Expression régulière pour trouver des nombres décimaux/flottants ?

Question

J'ai besoin d'une expression régulière pour les nombres décimaux/flottants comme 12 12.2 1236.32 123.333 et +12.00 or -12.00 ou ...123.123... pour une utilisation en javascript et jQuery. Merci.

Answer 1

Les réponses de Paulpro et lbsweek m'ont mené à ceci :

re=/^[+-]?(?:\d*\.)?\d+/;
>> /^[+-]?(?:\d*\.)?\d+$/

re.exec("1")
>> Array [ "1" ]

re.exec("1.5")
>> Array [ "1.5" ]

re.exec("-1")
>> Array [ "-1" ]

re.exec("-1.5")
>> Array [ "-1.5" ]

re.exec(".5")
>> Array [ ".5" ]

re.exec("")
>> null

re.exec("qsdq")
>> null

Answer 2

Voici ma méthode js, gérant les zéros en tête de chaîne

1- ^0[0-9]+\.?[0-9]*$ : trouvera les nombres commençant par 0 et suivis de nombres supérieurs à zéro avant le séparateur décimal, principalement ".". J'ai mis cela pour distinguer les chaînes contenant des nombres, par exemple, "0.111" de "01.111".

2- ([1-9]{1}[0-9]\.?[0-9]) : si une chaîne commence par 0 alors la partie qui est supérieure à 0 sera prise en compte. Les parenthèses sont utilisées ici car je voulais capturer uniquement les parties conformes à l'expression régulière.

3- ([0-9]\.?[0-9]): pour capturer uniquement la partie décimale de la chaîne.

En Javascript, st.match(regex), renverra un tableau dans lequel le premier élément contient la partie conforme. J'ai utilisé cette méthode dans l'événement onChange de l'élément d'entrée, de cette façon si l'utilisateur entre quelque chose qui viole l'expression régulière alors la partie violante n'est pas affichée du tout dans la valeur de l'élément mais s'il y a une partie qui est conforme à l'expression régulière, alors elle reste dans la valeur de l'élément.

const floatRegexCheck = (st) => {
    const regx1 = new RegExp("^0[0-9]+\\.?[0-9]*$"); // pour trouver les nombres commençant par 0
    let regx2 = new RegExp("([1-9]{1}[0-9]*\\.?[0-9]*)"); //si regx1 correspond alors cela supprimera les zéros en tête. 
    if (!st.match(regx1)) { 
        regx2 = new RegExp("([0-9]*\\.?[0-9]*)"); //si le nombre ne contient pas de 0 en tête de chaîne alors le formatage décimal standard prend place
    }
    st = st.match(regx2);
    if (st?.length > 0) {
        st = st[0];
    }
    return st;
}

Answer 3

Si vous voulez que cela fonctionne avec e, utilisez cette expression :

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

Voici un exemple en JavaScript :

var re = /^[+-]?[0-9]+([.][0-9]+)?([eE][+-]?[0-9]+)?$/;

console.log(re.test('1'));
console.log(re.test('1.5'));
console.log(re.test('-1'));
console.log(re.test('-1.5'));
console.log(re.test('1E-100'));
console.log(re.test('1E+100'));
console.log(re.test('.5'));
console.log(re.test('foo'));

Answer 4

Voici une réponse plus rigoureuse

^[+-]?0(?![0-9]).[0-9]*(?![.])$|^[+-]?[1-9]{1}[0-9]*.[0-9]*$|^[+-]?.[0-9]+$

Les valeurs suivantes correspondront (le signe +- fonctionne également)

.11234
0.1143424
11.21
1.

Les valeurs suivantes ne correspondent pas

00.1
1.0.00
12.2350.0.0.0.0.
.
....

Comment cela fonctionne

Le (?! regex) signifie une opération NOT

Décomposons la regex par l'opérateur | qui est le même que l'opérateur OR logique

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

Cette regex est pour vérifier que la valeur commence par 0

Vérifie d'abord le signe + et - avec 0 ou 1 fois ^[+-]

Puis vérifie s'il a un zéro initial 0

S'il en a un, alors la valeur suivante ne doit pas être un zéro car nous ne voulons pas voir 00.123 (?![0-9])

Ensuite, vérifiez le point exactement une fois et vérifiez la partie fractionnaire avec un nombre illimité de chiffres .[0-9]*

Enfin, s'il y a un point suivi de la partie fractionnaire, nous l'excluons. (?![.])$

Maintenant voyons la deuxième partie

^[+-]?[1-9]{1}[0-9]*.[0-9]*$

^[+-]? pareil comme ci-dessus

Si ça commence par différent de zéro, faites correspondre le premier chiffre exactement une fois et un nombre illimité de fois suivis de celui-ci [1-9]{1}[0-9]* par exemple 12.3, 1.2, 105.6

Faites correspondre le point une fois et un nombre illimité de chiffres qui le suivent .[0-9]*$

Maintenant voyons la troisième partie

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

Cela vérifiera si la valeur commence par un point. par exemple .12, .34565

^[+-]? pareil comme ci-dessus

Faites correspondre le point une fois et un ou plusieurs chiffres qui le suivent .[0-9]+$