Erkennen, ob eine Zeichenkette eine Zahl ist

Question

Wenn ich diese Saiten habe:

1. "abc" = false

2. "123" = true

3. "ab2" = false

Gibt es einen Befehl, wie IsNumeric() oder etwas anderes, das erkennen kann, ob eine Zeichenkette eine gültige Zahl ist?

Answer 1

Sie können immer die integrierten TryParse-Methoden für viele Datentypen verwenden, um zu sehen, ob die betreffende Zeichenkette passt.

Beispiel.

decimal myDec;
var Result = decimal.TryParse("123", out myDec);

Ergebnis wäre dann = Wahr

decimal myDec;
var Result = decimal.TryParse("abc", out myDec);

Ergebnis wäre dann = False

Answer 2

Falls Sie int.Parse oder double.Parse nicht verwenden möchten, können Sie Ihre eigene Methode anwenden, etwa so:

public static class Extensions
{
    public static bool IsNumeric(this string s)
    {
        foreach (char c in s)
        {
            if (!char.IsDigit(c) && c != '.')
            {
                return false;
            }
        }

        return true;
    }
}

Answer 3

Ich weiß, dies ist ein alter Thread, aber keine der Antworten hat mich wirklich überzeugt - entweder ineffizient oder nicht gekapselt für eine einfache Wiederverwendung. Ich wollte auch sicherstellen, dass es false zurückgegeben, wenn die Zeichenfolge leer oder null war. TryParse gibt in diesem Fall true zurück (eine leere Zeichenkette führt beim Parsen als Zahl nicht zu einem Fehler). So, hier ist meine String-Erweiterungsmethode:

public static class Extensions
{
    /// <summary>
    /// Returns true if string is numeric and not empty or null or whitespace.
    /// Determines if string is numeric by parsing as Double
    /// </summary>
    /// <param name="str"></param>
    /// <param name="style">Optional style - defaults to NumberStyles.Number (leading and trailing whitespace, leading and trailing sign, decimal point and thousands separator) </param>
    /// <param name="culture">Optional CultureInfo - defaults to InvariantCulture</param>
    /// <returns></returns>
    public static bool IsNumeric(this string str, NumberStyles style = NumberStyles.Number,
        CultureInfo culture = null)
    {
        double num;
        if (culture == null) culture = CultureInfo.InvariantCulture;
        return Double.TryParse(str, style, culture, out num) && !String.IsNullOrWhiteSpace(str);
    }
}

Einfach zu bedienen:

var mystring = "1234.56789";
var test = mystring.IsNumeric();

Wenn Sie andere Zahlentypen testen möchten, können Sie auch den "Stil" angeben. Um also eine Zahl mit einem Exponenten zu konvertieren, könnten Sie verwenden:

var mystring = "5.2453232E6";
var test = mystring.IsNumeric(style: NumberStyles.AllowExponent);

Oder um eine mögliche Hex-Zeichenkette zu testen, könnten Sie verwenden:

var mystring = "0xF67AB2";
var test = mystring.IsNumeric(style: NumberStyles.HexNumber)

Der optionale Parameter "culture" kann in ähnlicher Weise verwendet werden.

Es wird dadurch eingeschränkt, dass es nicht in der Lage ist, Zeichenketten zu konvertieren, die zu groß sind, um in einem Double enthalten zu sein, aber das ist eine begrenzte Anforderung, und ich denke, wenn Sie mit Zahlen arbeiten, die größer sind als diese, dann brauchen Sie wahrscheinlich sowieso zusätzliche spezialisierte Funktionen zur Zahlenverarbeitung.

Answer 4

Wenn Sie ein breiteres Spektrum an Zahlen erfassen möchten, wie z. B. PHPs ist_numerisch können Sie Folgendes verwenden:

// From PHP documentation for is_numeric
// (http://php.net/manual/en/function.is-numeric.php)

// Finds whether the given variable is numeric.

// Numeric strings consist of optional sign, any number of digits, optional decimal part and optional
// exponential part. Thus +0123.45e6 is a valid numeric value.

// Hexadecimal (e.g. 0xf4c3b00c), Binary (e.g. 0b10100111001), Octal (e.g. 0777) notation is allowed too but
// only without sign, decimal and exponential part.
static readonly Regex _isNumericRegex =
    new Regex(  "^(" +
                /*Hex*/ @"0x[0-9a-f]+"  + "|" +
                /*Bin*/ @"0b[01]+"      + "|" + 
                /*Oct*/ @"0[0-7]*"      + "|" +
                /*Dec*/ @"((?!0)|[-+]|(?=0+\.))(\d*\.)?\d+(e\d+)?" + 
                ")$" );
static bool IsNumeric( string value )
{
    return _isNumericRegex.IsMatch( value );
}

Einheitstest:

static void IsNumericTest()
{
    string[] l_unitTests = new string[] { 
        "123",      /* TRUE */
        "abc",      /* FALSE */
        "12.3",     /* TRUE */
        "+12.3",    /* TRUE */
        "-12.3",    /* TRUE */
        "1.23e2",   /* TRUE */
        "-1e23",    /* TRUE */
        "1.2ef",    /* FALSE */
        "0x0",      /* TRUE */
        "0xfff",    /* TRUE */
        "0xf1f",    /* TRUE */
        "0xf1g",    /* FALSE */
        "0123",     /* TRUE */
        "0999",     /* FALSE (not octal) */
        "+0999",    /* TRUE (forced decimal) */
        "0b0101",   /* TRUE */
        "0b0102"    /* FALSE */
    };

    foreach ( string l_unitTest in l_unitTests )
        Console.WriteLine( l_unitTest + " => " + IsNumeric( l_unitTest ).ToString() );

    Console.ReadKey( true );
}

Nur weil ein Wert numerisch ist, heißt das nicht, dass er in einen numerischen Typ konvertiert werden kann. Zum Beispiel, "999999999999999999999999999999.9999999999" ist ein vollkommen gültiger numerischer Wert, aber er passt nicht in einen numerischen Typ von .NET (also nicht in einen, der in der Standardbibliothek definiert ist).

Answer 5

UPDATE von Kunal Noel Antwort

stringTest.All(char.IsDigit);
// This returns true if all characters of the string are digits.

Aber für diesen Fall haben wir, dass leere Zeichenfolgen diesen Test bestehen, so können Sie:

if (!string.IsNullOrEmpty(stringTest) && stringTest.All(char.IsDigit)){
   // Do your logic here
}