Comment valider le numéro en perl?

Je sais qu'il y a une bibliothèque qui ne sont que

utilisation Scalar::Util qw(looks_like_number);

mais je veux le faire à l'aide d'expressions régulières perl. Et je veux qu'il travail pour le double numéros qui ne sont pas seulement pour les nombres entiers.

donc je veux quelque chose de mieux que ce

$var =~ /^[+-]?\d+$/

grâce.

Vous savez que deimal numéros pourrait avoir une partie facultative (....)? après la partie. Vous cuo ai essayé un peu, au moins.
j'ai essayé celui que je mets sur ma question et il n'a pas de travail lors de la vérification d'un certain nombre comme (3.5) comme exemple.
Il a FAIT un travail - il a dit que vous correctement, que votre profil ne correspond pas à l'ensemble de la chaîne "3.5"
rosettacode.org/wiki/Determine_if_a_string_is_numeric#Perl
Pourquoi ne pas utiliser Scalar::Util? Il fait partie de la NORME bibliothèque Perl et est donc presque toujours disponibles pour la programmation de l'utiliser. De Plus, Scalar::Util peut gérer "0 mais vrai", qui est valide Perl nombre -- quelque chose que votre expression régulière peut pas gérer.

OriginalL'auteur little star | 2011-05-11

  1. 15

    La construction d'une seule expression régulière pour valider un certain nombre qui est vraiment difficile. Il n'ya tout simplement trop beaucoup de critères à prendre en compte. Perlfaq4 contient une section "Comment puis-je déterminer si un scalaire est un nombre/entier/entier/float?

    Le code à partir de cette documentation montre les tests suivants:

    if (/\D/)                          {print "has nondigits\n"      }
if (/^\d+$/)                       {print "is a whole number\n"  }
if (/^-?\d+$/)                     {print "is an integer\n"      }
if (/^[+-]?\d+$/)                  {print "is a +/- integer\n"   }
if (/^-?\d+\.?\d*$/)               {print "is a real number\n"   }
if (/^-?(?:\d+(?:\.\d*)?|\.\d+)$/) {print "is a decimal number\n"}
if (/^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/) {
    print "is a C float\n"
}
    • Le premier test disqualifie un entier non signé.
    • Le deuxième test est admissible à un nombre entier.
    • Le troisième test est admissible à un entier.
    • Le quatrième essai qualifie positivement/négativement entier signé.
    • Le cinquième essai qualifie un nombre réel.
    • Le sixième test qualifie un nombre décimal.
    • La septième test est admissible à un certain nombre de c-style notation scientifique.

    Donc si vous utilisez ces essais (à l'exclusion de la première), vous avez pour vérifier que l'un ou plusieurs des tests de passe. Et puis, vous avez un certain nombre.

    Une autre méthode, puisque vous ne voulez pas utiliser le module Scalar::Util, vous pouvez apprendre le code DE la Scalar::Util. Le looks_like_number() la fonction est définie de la manière suivante:

    sub looks_like_number {
  local $_ = shift;

  # checks from perlfaq4
  return $] < 5.009002 unless defined;
  return 1 if (/^[+-]?\d+$/); # is a +/- integer
  return 1 if (/^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/); # a C float
  return 1 if ($] >= 5.008 and /^(Inf(inity)?|NaN)$/i) 
           or ($] >= 5.006001 and /^Inf$/i);

  0;
}

    Vous devriez être en mesure d'utiliser les parties de fonction qui sont applicables à votre situation.

    Je tiens à souligner, cependant, que Scalar::Util est un core module Perl; il est livré avec Perl, tout comme strict n'. Le meilleur de la pratique de tous est probablement juste de l'utiliser.

    La fonction que vous avez affichée diffère de sortie pour l'entrée looks_like_number('0 but true')!
    ...et pour surchargées d'objets. Surchargé d'objets sont traités dans la dernière version de la Scalar::Util::PP. Le PP version n'existe plus dans le dernier dev version de la distrib.
    Oui, il semble que le Scalaire-Liste-Utils-1.23 avait un pur Perl version, alors que le Scalaire-Liste-Utils-1.23_03 ne le fait pas. Le lecteur peut facilement chercher la source pour v1.23 sur le CPAN, que cette version ne poignée surchargé d'objets. Toutefois, j'estime que ce dialogue sert à rappeler le point qu'il est insensé d'essayer de construire une nouvelle généralisée nombre admissible solution d'expressions régulières lorsque Scalar::Util de looks_like_number() existe déjà; c'est presque certain d'être plus robuste, plus moderne, et plus maintenable. De Plus, il fait partie de la norme de distribution Perl.
    D'accord. En effet, il était mon intention d'appuyer ce point.
    sous looks_like_number - ce fonctionne vraiment bien. Mon analyseur a été la lecture de vraiment bizarre nums qui a glissé à travers mon arrivée standard, comme 5.23.14 ou 2..6 ou 1.-5 merci!

    OriginalL'auteur DavidO

  2. 6

    Vous devez utiliser Regexp::Common, la plupart des modèles sont plus compliquées que vous ne le réalisez.

    use Regexp::Common;

my $real = 3.14159;
print "Real" if $real =~ /$RE{num}{real}/;

    Cependant, le modèle n'est pas ancré par défaut, donc une version plus stricte est:

    my $real_pat = $RE{num}{real};
my $real     = 3.14159;
print "Real" if $real =~ /^$real_pat$/;
    Malheureusement, Regexp::Common passe des choses que l'homme normal peut envisager un nombre valide la syntaxe, telles que: '1..2', '-1.0.2', et '1.-2'. Un autre cas de soutien, au point que la Scalar::Util approche est la meilleure façon.
    La documentation indique que le match n'est pas ancré. Ces modèles ne correspondent pas à un nombre réel si ancré comme indiqué là. Ils ne correspondent si non ancré.
    Il serait peut-être raisonnable de modifier ton post en accord avec la plus robuste de la regex: m/^$RE{num}{real}$/. Je n'ai pas testé si cela allait rejeter "1.-2" si. BTW: je n'ai ++ votre réponse.
    Excellente pensée, c'est fait.

    OriginalL'auteur Bill Ruppert

  3. 0

    Eh bien d'abord, vous devez vous assurer que le numéro ne contient pas de virgules si vous faites cela:

    $var =~ s/,//g; # supprime tous les virgules

    Alors créer une autre variable pour faire le reste de la comparer.

    $var2=$var;

    Puis retirez le . à partir de la nouvelle variable mais seulement une fois à l'événement.

    $var2 =~ s/.//; # remplacer . avec rien à comparer encore une fois.

    maintenant var2 devrait ressembler à un nombre entier qui n'a pas "."
    afin de faire ceci:

        if($var2 !~ /^[+-]?\d+$/){
        print "not valid";
    }else{
       #use var1 
    }

    vous pouvez corriger ce code et de l'écrire comme une fonction de si vous avez besoin d'utiliser plus d'une fois.
    Cheers!

    OriginalL'auteur Luci