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

Correspondance facultative avec un + ou - au début, suivi d'un ou plusieurs chiffres décimaux, optionnellement suivi d'un point décimal et d'un ou plusieurs chiffres décimaux jusqu'à la fin de la chaîne:

/^[+-]?\d+(\.\d+)?$/

RegexPal

Answer 2

La bonne expression devrait être comme suit :

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

ceci s'applique pour :

+1
+1.
+.1
+0.1
1
1.
.1
0.1

Voici un exemple en Python :

import re
#afficher si trouvé
print(bool(re.search(r'[+-]?([0-9]*[.])?[0-9]+', '1.0')))
#afficher le résultat
print(re.search(r'[+-]?([0-9]*[.])?[0-9]+', '1.0').group(0))

Résultat :

True
1.0

Si vous utilisez un Mac, vous pouvez tester dans la ligne de commande :

python -c "import re; print(bool(re.search(r'[+-]?([0-9]*[.])?[0-9]+', '1.0')))"

python -c "import re; print(re.search(r'[+-]?([0-9]*[.])?[0-9]+', '1.0').group(0))"

Answer 3

Vous pouvez vérifier la validation du texte et également la validation d'un seul point décimal en utilisant isNaN

var val = $('#textbox').val();
var floatValues =  /[+-]?([0-9]*[.])?[0-9]+/;
 if (val.match(floatValues) && !isNaN(val)) {
  // votre fonction
}

Answer 4

Pour les nouveaux :

J'ai créé une RegExp pour la notation scientifique E (correspondant à toute la chaîne).

const floatR = /^[+-]?(?:[0-9]+(?:\.[0-9]+)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/;

floatR.test("-2.3E23"); //=> true
floatR.test("-2.E");    //=> false
floatR.test("  2  ");   //=> false

Si vous préférez utiliser les nombres Unicode, vous pouvez remplacer tous les [0-9] par \d dans la RegExp.
Et éventuellement ajouter le drapeau Unicode u à la fin de la RegExp.

Pour une meilleure compréhension du motif, consultez https://regexper.com/.
Et pour créer des RegExp, je peux vous suggérer https://regex101.com/.

MODIFICATION : j'ai trouvé un autre site pour visualiser les RegExp en couleur : [https://jex.im/regulex/](https://jex.im/regulex/#!flags=&re=%5E(%5B%2B-%5D%3F%28%3F%3A%5B0-9%5D%2B%28%3F%3A%5C.%5B0-9%5D%2B%29%3F%7C%5C.%5B0-9%5D%2B%29%28%3F%3A%5BeE%5D%5B%2B-%5D%3F%5B0-9%5D%2B%29%3F%29%24).

MODIFICATION 2 : bien que l'op demande spécifiquement des RegExp, vous pouvez vérifier une chaîne directement en JS :

/**
 * ## Analyser {@linkcode str} en nombre
 * @param {string} str - la chaîne à analyser
 * @returns {number | null} le nombre analysé ou `null` si ce n'est pas un nombre
 */
const parseNum = str => Number.isNaN(str = Number(str)) ? null : str;

parseNum("123.12345678E+3") ?? 1; //=> 123123.45678
parseNum("80F") ?? 1;             //=> 1

Conversion de la chaîne en nombre (ou NaN) avec Number()
puis vérification s'il n'est PAS NaN avec !Number.isNaN()

MODIFICATION 3 : j'ai trouvé un autre site sympa : voir cette regexp sur debuggex.com.

MODIFICATION 4 : Si vous voulez exclure les 0 en tête/queue, utilisez ce qui suit

// Exclure les zéros en tête mais pas en queue
const floatR_L = /^[+-]?(?:[1-9][0-9]*(?:\.[0-9]+)?|\.[0-9]+)(?:[eE][+-]?[1-9][0-9]*)?$/;

// Exclure les zéros en tête et en queue
const floatR_LT = /^[+-]?(?:[1-9][0-9]*(?:\.[0-9]*[1-9])?|\.[0-9]*[1-9])(?:[eE][+-]?[1-9][0-9]*)?$/;

Aussi, en JavaScript, les nombres peuvent inclure des tirets bas comme des séparateurs numériques, donc pour être exhaustif, ceci devrait correspondre à n'importe quel littéral de nombre JS valide :

// Correspond à : +- `Infinity`, `NaN`, ou nombre avec `_` comme séparateur numérique, `E` notation scientifique, zéros en tête/en queue, (pas de `.` ou `E` pour →) test pour préfixe `0b` (binaire), `0` (quand tous les chiffres sont inférieurs à 8) ou `0o` (octal), et `0x` (hexadécimal), et suffixe `n` pour BigInt (pas de `+` et pas de zéros en tête sauf lorsqu'ils sont utilisés avec préfixe `0o`/`0x`/`0b`)
const JSNumberLiteralRegExp = /^([+-]?(?:NaN|Infinity|0(?:[bB][01](?:_?[01]+)*|[oO]?[0-7](?:_?[0-7]+)*|[xX][0-9a-fA-F](?:_?[0-9a-fA-F]+)*)|(?:(?:0|0(?:[0-9](?:_?[0-9]+)*)?[89](?:[0-9](?:_?[0-9]+)*)?|[1-9](?:_?[0-9]+)*)(?:\.(?:[0-9](?:_?[0-9]+)*)?)?|\.[0-9](?:_?[0-9]+)*)(?:[eE][+-]?[0-9](?:_?[0-9]+)*)?)|-?(?:0(?:[bB][01](?:_?[01]+)*|[oO][0-7](?:_?[0-7]+)*|[xX][0-9a-fA-F](?:_?[0-9a-fA-F]+)*)?|[1-9](?:_?[0-9]+)*)n)$/;

Remarque : Certains linters n'autorisent pas les zéros en tête dans les fichiers JS car ils sont traités comme des littéraux octaux sans les préfixes 0o.

MODIFICATION 5 : mis à jour la RegExp ci-dessus pour prendre en charge les bigint et quelques cas limites supplémentaires que j'ai trouvés (voir ci-dessous)

regex101 - exemples de correspondances et tests unitaires
Regulex%7C(%3F%3A(%3F%3A0%7C0(%3F%3A%5B0-9%5D(%3F%3A%3F%5B0-9%5D%2B)*)%3F%5B89%5D(%3F%3A%5B0-9%5D(%3F%3A%3F%5B0-9%5D%2B))%3F%7C%5B1-9%5D(%3F%3A_%3F%5B0-9%5D%2B))(%3F%3A%5C.(%3F%3A%5B0-9%5D(%3F%3A%3F%5B0-9%5D%2B)*)%3F)%3F%7C%5C.%5B0-9%5D(%3F%3A%3F%5B0-9%5D%2B))(%3F%3A%5BeE%5D%5B%2B-%5D%3F%5B0-9%5D(%3F%3A_%3F%5B0-9%5D%2B))%3F)%7C-%3F(%3F%3A0(%3F%3A%5BbB%5D%5B01%5D(%3F%3A%3F%5B01%5D%2B)*%7C%5BoO%5D%5B0-7%5D(%3F%3A%3F%5B0-7%5D%2B)%7C%5BxX%5D%5B0-9a-fA-F%5D(%3F%3A_%3F%5B0-9a-fA-F%5D%2B))%3F%7C%5B1-9%5D(%3F%3A%3F%5B0-9%5D%2B)*)n)%24 "Voir la RegExp sur jex.im/regulex") - graphe coloré
[Regexper](https://regexper.com/#%2F%5E%28%5B%2B-%5D%3F%28%3F%3ANaN%7CInfinity%7C0%28%3F%3A%5BbB%5D%5B01%5D%28%3F%3A%3F%5B01%5D%2B%29%7C%5BoO%5D%3F%5B0-7%5D%28%3F%3A_%3F%5B0-7%5D%2B%29%7C%5BxX%5D%5B0-9a-fA-F%5D%28%3F%3A%3F%5B0-9a-fA-F%5D%2B%29*%29%7C%28%3F%3A%28%3F%3A0%7C0%28%3F%3A%5B0-9%5D%28%3F%3A%3F%5B0-9%5D%2B%29%29%3F%5B89%5D%28%3F%3A%5B0-9%5D%28%3F%3A_%3F%5B0-9%5D%2B%29%29%3F%7C%5B1-9%5D(%3F%3A%3F%5B0-9%5D%2B%29*%29%28%3F%3A%5C.(%3F%3A%5B0-9%5D%28%3F%3A%3F%5B0-9%5D%2B%29%29%3F%29%3F%7C%5C.%5B0-9%5D%28%3F%3A_%3F%5B0-9%5D%2B%29%29%28%3F%3A%5BeE%5D%5B%2B-%5D%3F%5B0-9%5D(%3F%3A%3F%5B0-9%5D%2B%29*%29%3F%29%7C-%3F%28%3F%3A0%28%3F%3A%5BbB%5D%5B01%5D%28%3F%3A%3F%5B01%5D%2B%29%7C%5BoO%5D%5B0-7%5D(%3F%3A_%3F%5B0-7%5D%2B%29%7C%5BxX%5D%5B0-9a-fA-F%5D(%3F%3A%3F%5B0-9a-fA-F%5D%2B%29*%29%3F%7C%5B1-9%5D(%3F%3A%3F%5B0-9%5D%2B%29*%29n%29%24%2F "Voir la RegExp sur regexper.com") - graphe légèrement plus petit et moins coloré

• +/- Infinity et NaN
• _ comme séparateur numérique entre deux chiffres quelconques
• Nombre
  • . en tête/en queue (point décimal)
  • zéros en tête
    • [!] peut être interprété comme octal (voir ci-dessous)
  • préfixe
    • 0b binaire
      • pas de . ou de notation scientifique
    • 0o octal
      • [!] également implicite avec un zéro initial et lorsque tous les chiffres (avant tout .) sont inférieurs à 8
      • pas de . ou de notation scientifique
    • 0x hexadécimal
      • pas de . ou de notation scientifique
        • [!] le E en notation scientifique fera partie du nombre hexadécimal
• BigInt
  • explicité par suffixe n
  • pas de zéros en tête sauf après un préfixe 0o/0x/0b
  • pas de +, ., ou de notation scientifique

Remarquez, Number() autorise les espaces en tête/en queue, mais pas le _, et les zéros en tête ne sont pas un préfixe octal implicite, (et bien sûr pas de suffixe BigInt)

Answer 5

Ceci est un ancien message mais c'était le meilleur résultat de recherche pour "expression régulière pour le point flottant" ou quelque chose comme ça et ne répond pas tout à fait à _ma_ question. Comme je l'ai résolu, je vais partager mon résultat pour que la prochaine personne qui tombe sur ce fil de discussion n'ait pas à le résoudre par elle-même.

Toutes les réponses jusqu'à présent acceptent un zéro initial sur les chiffres de deux (ou plus) chiffres à gauche du point décimal (par exemple 0123 au lieu de simplement 123). Ce n'est pas vraiment valide et dans certains contextes, il est utilisé pour indiquer que le nombre est en octal (base-8) plutôt que le format décimal habituel (base-10).

De plus, ces expressions acceptent un décimal sans zéro initial (.14 au lieu de 0.14) ou sans partie fractionnaire finale (3. au lieu de 3.0). C'est valide dans certains contextes de programmation (y compris JavaScript) mais je veux les interdire (parce que pour mes besoins, ils sont plus susceptibles d'être une erreur intentionnelle).

Ignorant la "notation scientifique" comme 1.234E7, voici une expression qui répond à mes critères :

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

ou si vous voulez vraiment accepter un signe + initial, alors :

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

Je crois que cette expression régulière effectuera un test strict pour le nombre flottant typique au style entier ou décimal.

Lorsqu'il est trouvé :

• $1 contient le nombre complet qui correspond
• $2 contient le signe initial (éventuellement vide) (+/-)
• $3 contient la valeur à gauche du point décimal
• $5 contient la valeur à droite du point décimal, y compris le point initial .

Par "strict", je veux dire que le nombre doit être la seule chose dans la chaîne que vous testez.

Si vous voulez extraire juste la valeur flottante d'une chaîne qui contient d'autres contenus, utilisez cette expression :

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

Qui trouvera -3.14 dans "le négatif pi est approximativement -3.14." ou dans "(-3.14)" etc.

Les groupes numérotés ont la même signification que ci-dessus (à l'exception que $2 est maintenant une chaîne vide ("") lorsqu'il n'y a pas de signe initial, plutôt que null).

Mais sachez qu'il essaiera également d'extraire tous les chiffres qu'il peut trouver. Par exemple, il extraira 127.0 de 127.0.0.1.

Si vous voulez quelque chose de plus sophistiqué que cela, je pense que vous devriez envisager l'analyse lexicale plutôt que les expressions régulières. Je suppose que l'on pourrait créer une expression basée sur l'anticipation qui reconnaîtrait que "Pi est 3.14." contient un nombre flottant mais que Maison est 127.0.0.1. ne le fait pas, mais ce serait compliqué au mieux. Si votre modèle dépend des caractères qui viennent après de manière non triviales, vous commencez à sortir du domaine de prédilection des expressions régulières.