Quelle expression régulière puis-je utiliser pour les valeurs numériques et décimales positives?
^\d*\.?\d*[1-9]+\d*$)|(^[1-9]+\d*\.\d*$
J'ai essayé mais j'obtiens une erreur
^\d*\.?\d*[1-9]+\d*$)|(^[1-9]+\d*\.\d*$"
Trop de)
Accepted values: 0, 22.5 , 0.35 , 89 , .38 Invalid values : -22 , -.25 , -0.66 , abc, -22abc, 55er
5 Réponses :
Il vous manque un ) de fermeture dans l'expression régulière.
^\d*\.?\d*[1-9]+\d*$)|(^[1-9]+\d*\.\d*)$
Cependant, je vous suggère fortement de regarder Decimal.TryParse code> au lieu d'essayer de valider vous-même les nombres en utilisant le format d'une chaîne.
Était sur le point de commenter ce dernier paragraphe. Plus facile à lire (et donc à maintenir) trop IMO. +1 pour la suggestion d'une meilleure option.
Cette expression régulière n'a toujours pas de parenthèse ouvrante, ce qui la rend non valide. Comme je peux le voir, les parenthèses ne sont même pas nécessaires pour cette expression régulière. De plus, cette expression régulière est inutilement complexe et peut être simplifiée.
Je voudrais simplement votre modèle à ceci:
(?=.)\d*(?:\.\d+)?
Cela semble couvrir tous vos cas d'utilisation de nombres décimaux positifs. Le composant décimal est facultatif, ce qui signifie que le modèle couvre les entiers. Les nombres décimaux sont couverts, ainsi que les nombres qui n'ont qu'un composant décimal.
Notez que vous devrez peut-être entourer le modèle avec des ancres ^ $ , selon l'API particulière que vous utilisez en utilisant.
Modifier:
Si vous avez également besoin de vous assurer que la chaîne vide ne correspond pas, nous pouvons ajouter une anticipation au modèle ci-dessus:
\d*(?:\.\d+)?
Petit problème dans cette expression régulière car elle correspondra également à une chaîne vide.
@PushpeshKumarRajwanshi Merci de l'avoir signalé. J'ai ajouté un correctif pour le problème que vous avez identifié.
Ou, si vous voulez rester à l'écart de Regex, l'un de ces éléments pourrait fonctionner:
private static bool TryParsePositiveDecimal(string decimalString, out decimal aDecimal)
{
return decimal.TryParse(decimalString, out aDecimal) && aDecimal >= 0;
}
ou
private static bool IsPositiveDecimal(string decimalString)
{
return decimal.TryParse(decimalString, out var aDecimal) && aDecimal >= 0;
}
Si vous alimentez le dernier est un décimal non positif, il retournera faux, mais retournera le décimal analysé dans le paramètre out.
Cela devrait répondre à vos besoins sans injecter un Regex compliqué dans votre code.
Je pense que cette expression régulière devrait répondre à tous les cas et ne correspondra qu'aux échantillons valides et rejettera tous les échantillons non valides.
^(?:[1-9]\d*(\.\d+)?|0?\.\d+|0)$
Explication de l'expression régulière:
^ - Début de chaîne (?: - Début du groupe sans capture [1-9] \ d * - Correspond à un nombre sans zéros précédents inutiles. Sera invalidé 01 ou 001 (\. \ d +)? - Peut éventuellement avoir une partie décimale | - Alternance 0? \. \ d + - Autorise uniquement les nombres décimaux qui peuvent éventuellement avoir zéro devant eux. Par exemple. pour prendre en charge des nombres tels que 0.11 ou .11 | - Alternance 0 - Prise en charge du zéro littéral comme cas particulier ) - fermeture du groupe sans capture $ - Fin de chaîne ^\d*\.?\d+$ There will also match 0.00 .00 0.0
Où voulez-vous l'utiliser? Comme indiqué dans la réponse @stimms, utiliser
decimal.TryParseet une simple comparaison serait plus à l'épreuve des ballesJ'utiliserai ceci sur l'événement de zone de texte txtbox_PreviewTextInput dans wpf. J'ai une méthode en place qui valide l'entrée et si elle n'est pas valide, elle rejette l'entrée de l'utilisateur.
Ensuite, combinez simplement
decimal.TryParseen cascade avec une comparaison avec0m(il n'est pas clair d'après votre question si 0 est une valeur «positive» valide). C'est beaucoup plus simple et plus facile à lire.zéro est la valeur valide.