Wie kann ich feststellen, ob eine Variable in Perl einen numerischen Wert hat?

Gibt es eine einfache Möglichkeit in Perl, mit der ich feststellen kann, ob eine bestimmte Variable numerisch ist? Etwas in der Art von:

if (is_number($x))
{ ... }

wäre ideal. Eine Technik, die bei Verwendung des -wSchalters keine Warnungen auslöst, wird sicherlich bevorzugt.

Verwenden Sie Scalar::Util::looks_like_number()diese Option, um die Funktion look_like_number () der internen Perl C-API zu verwenden. Dies ist wahrscheinlich der effizienteste Weg, dies zu tun. Beachten Sie, dass die Zeichenfolgen "inf" und "unendlich" als Zahlen behandelt werden.

Beispiel:

#!/usr/bin/perl

use warnings;
use strict;

use Scalar::Util qw(looks_like_number);

my @exprs = qw(1 5.25 0.001 1.3e8 foo bar 1dd inf infinity);

foreach my $expr (@exprs) {
    print "$expr is", looks_like_number($expr) ? '' : ' not', " a number\n";
}

Gibt diese Ausgabe:

1 is a number
5.25 is a number
0.001 is a number
1.3e8 is a number
foo is not a number
bar is not a number
1dd is not a number
inf is a number
infinity is a number

Siehe auch:

• perldoc Scalar :: Util
• perldoc perlapi fürlooks_like_number

Schauen Sie sich das CPAN-Modul Regexp :: Common an . Ich denke, es macht genau das, was Sie brauchen, und behandelt alle Randfälle (z. B. reelle Zahlen, wissenschaftliche Notation usw.). z.B

use Regexp::Common;
if ($var =~ /$RE{num}{real}/) { print q{a number}; }

Die ursprüngliche Frage war, wie man erkennt, ob eine Variable numerisch ist, nicht, ob sie "einen numerischen Wert hat".

Es gibt einige Operatoren, die getrennte Betriebsmodi für numerische und Zeichenfolgenoperanden haben, wobei "numerisch" alles bedeutet, was ursprünglich eine Zahl war oder jemals in einem numerischen Kontext verwendet wurde (z. B. in $x = "123"; 0+$x, bevor die Addition $xeine Zeichenfolge ist, danach wird als numerisch betrachtet).

Eine Möglichkeit zu sagen ist folgende:

if ( length( do { no warnings "numeric"; $x & "" } ) ) {
    print "$x is numeric\n";
}

Wenn die bitweise Funktion aktiviert ist, die &nur einen numerischen Operator erstellt und einen separaten Zeichenfolgenoperator hinzufügt &., müssen Sie sie deaktivieren:

if ( length( do { no if $] >= 5.022, "feature", "bitwise"; no warnings "numeric"; $x & "" } ) ) {
    print "$x is numeric\n";
}

(bitweise ist in Perl 5.022 und höher verfügbar und standardmäßig aktiviert, wenn Sie use 5.028;oder höher.)

Eine einfache (und vielleicht vereinfachende) Antwort auf die Frage lautet: Der Inhalt der $xnumerischen lautet wie folgt:

if ($x  eq  $x+0) { .... }

Es wird ein Textvergleich des Originals $xmit dem $xin einen numerischen Wert konvertierten Wert durchgeführt.

Normalerweise erfolgt die Validierung von Zahlen mit regulären Ausdrücken. Dieser Code bestimmt, ob etwas numerisch ist, und sucht nach undefinierten Variablen, um keine Warnungen auszulösen:

sub is_integer {
   defined $_[0] && $_[0] =~ /^[+-]?\d+$/;
}

sub is_float {
   defined $_[0] && $_[0] =~ /^[+-]?\d+(\.\d+)?$/;
}

Hier ist etwas Lesematerial, das Sie sich ansehen sollten.

Nicht perfekt, aber Sie können einen regulären Ausdruck verwenden:

sub isnumber 
{
    shift =~ /^-?\d+\.?\d*$/;
}

Ich glaube nicht, dass etwas eingebaut ist, um es zu tun. Weitere Informationen zu diesem Thema finden Sie unter Perlmonks zum Erkennen von Zahlen

Eine etwas robustere Regex finden Sie in Regexp :: Common .

Es hört sich so an, als ob Sie wissen möchten, ob Perl eine Variable für numerisch hält. Hier ist eine Funktion, die diese Warnung abfängt:

sub is_number{
  my $n = shift;
  my $ret = 1;
  $SIG{"__WARN__"} = sub {$ret = 0};
  eval { my $x = $n + 1 };
  return $ret
}

Eine andere Möglichkeit besteht darin, die Warnung lokal auszuschalten:

{
  no warnings "numeric"; # Ignore "isn't numeric" warning
  ...                    # Use a variable that might not be numeric
}

Beachten Sie, dass nicht numerische Variablen stillschweigend in 0 konvertiert werden, was wahrscheinlich sowieso das ist, was Sie wollten.

rexep nicht perfekt ... das ist:

use Try::Tiny;

sub is_numeric {
  my ($x) = @_;
  my $numeric = 1;
  try {
    use warnings FATAL => qw/numeric/;
    0 + $x;
  }
  catch {
    $numeric = 0;
  };
  return $numeric;
}

Versuche dies:

If (($x !~ /\D/) && ($x ne "")) { ... }

Ich fand das allerdings interessant

if ( $value + 0 eq $value) {
    # A number
    push @args, $value;
} else {
    # A string
    push @args, "'$value'";
}

Persönlich denke ich, dass der Weg dahin darin besteht, sich auf den internen Kontext von Perl zu verlassen, um die Lösung kugelsicher zu machen. Ein guter regulärer Ausdruck könnte mit allen gültigen numerischen Werten und keinem der nicht numerischen Werte übereinstimmen (oder umgekehrt). Da es jedoch eine Möglichkeit gibt, dieselbe Logik zu verwenden, die der Interpreter verwendet, sollte es sicherer sein, sich direkt darauf zu verlassen.

Da neige ich dazu, meine Skripte mit auszuführen -w , musste ich die Idee, das Ergebnis von "Wert plus Null" mit dem ursprünglichen Wert zu vergleichen, mit dem no warningsbasierten Ansatz von @ysth kombinieren:

do { 
    no warnings "numeric";
    if ($x + 0 ne $x) { return "not numeric"; } else { return "numeric"; }
}

Sie können reguläre Ausdrücke verwenden, um festzustellen, ob $ foo eine Zahl ist (oder nicht).

Schauen Sie hier: Wie bestimme ich, ob ein Skalar eine Zahl ist?

if (definiert $ x && $ x! ~ m / \ D /) {} oder $ x = 0 if! $ x; if ($ x! ~ m / \ D /) {}

Dies ist eine geringfügige Abweichung von Veekays Antwort, aber lassen Sie mich meine Gründe für die Änderung erläutern.

Das Ausführen eines regulären Ausdrucks für einen undefinierten Wert führt zu Fehlern und führt dazu, dass der Code in vielen, wenn nicht in den meisten Umgebungen beendet wird. Wenn Sie testen, ob der Wert definiert ist, oder einen Standardfall festlegen, wie ich es im alternativen Beispiel getan habe, bevor Sie den Ausdruck ausführen, wird mindestens Ihr Fehlerprotokoll gespeichert.