it-swarm.com.de

Identifizieren Sie, ob eine Zeichenfolge eine Zahl ist

Wenn ich diese Saiten habe:

  1. "abc" = false

  2. "123" = true

  3. "ab2" = false

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

670
Gold
int n;
bool isNumeric = int.TryParse("123", out n);

pdate Ab C # 7:

var isNumeric = int.TryParse("123", out int n);

Die var s können durch ihre jeweiligen Typen ersetzt werden!

1051
mqp

Dies gibt true zurück, wenn input alle Zahlen sind. Ich weiß nicht, ob es besser ist als TryParse, aber es wird funktionieren.

Regex.IsMatch(input, @"^\d+$")

Wenn Sie nur wissen möchten, ob eine oder mehrere Ziffern mit Zeichen gemischt sind, lassen Sie die Zeichen ^+ und $ weg.

Regex.IsMatch(input, @"\d")

Edit: Eigentlich denke ich, es ist besser als TryParse, weil ein sehr langer String TryParse möglicherweise überlaufen könnte.

344
John M Gant

Sie können auch verwenden:

stringTest.All(char.IsDigit);

Es wird true für alle numerischen Ziffern (nicht float) und false zurückgegeben, wenn es sich bei der Eingabe um eine alphanumerische Zeichenfolge handelt.

Bitte beachten Sie: stringTest sollte keine leere Zeichenfolge sein, da dies den Test als numerisch bestehen würde.

173
Kunal Goel

Ich habe diese Funktion mehrmals verwendet:

public static bool IsNumeric(object Expression)
{
    double retNum;

    bool isNum = Double.TryParse(Convert.ToString(Expression), System.Globalization.NumberStyles.Any, System.Globalization.NumberFormatInfo.InvariantInfo, out retNum);
    return isNum;
}

Sie können aber auch verwenden;

bool b1 = Microsoft.VisualBasic.Information.IsNumeric("1"); //true
bool b2 = Microsoft.VisualBasic.Information.IsNumeric("1aa"); // false

Von Benchmarking IsNumeric Options

alt text
(Quelle: aspalliance.com )

alt text
(Quelle: aspalliance.com )

124
Nelson Miranda

Dies ist wahrscheinlich die beste Option in C #.

Wenn Sie wissen möchten, ob die Zeichenfolge eine ganze Zahl (Ganzzahl) enthält:

string someString;
// ...
int myInt;
bool isNumerical = int.TryParse(someString, out myInt);

Die TryParse-Methode versucht, die Zeichenfolge in eine Zahl (Ganzzahl) umzuwandeln. Wenn dies erfolgreich ist, wird true zurückgegeben und die entsprechende Zahl in myInt eingefügt. Wenn dies nicht möglich ist, wird false zurückgegeben.

Lösungen, die die in anderen Antworten gezeigte Alternative int.Parse(someString) verwenden, funktionieren, sind jedoch viel langsamer, da das Auslösen von Ausnahmen sehr teuer ist. TryParse(...) wurde der C # -Sprache in Version 2 hinzugefügt, und bis dahin hatten Sie keine Wahl. Jetzt tun Sie es: Sie sollten daher die Alternative Parse() meiden.

Wenn Sie Dezimalzahlen akzeptieren möchten, verfügt die Dezimalklasse auch über eine .TryParse(...) -Methode. Ersetzen Sie int in der obigen Diskussion durch decimal, und es gelten dieselben Prinzipien.

32
Euro Micelli

Sie können für viele Datentypen immer die integrierten TryParse-Methoden verwenden, um festzustellen, ob die betreffende Zeichenfolge erfolgreich ist.

Beispiel.

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

Ergebnis wäre dann = True

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

Ergebnis wäre dann = Falsch

25
TheTXI

Wenn Sie int.Parse oder double.Parse nicht verwenden möchten, können Sie Ihre eigenen mit etwas wie folgendem würfeln:

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;
    }
}
19
BFree

Ich weiß, dass dies ein alter Thread ist, aber keine der Antworten hat es wirklich für mich getan - entweder ineffizient oder für die einfache Wiederverwendung nicht gekapselt. Ich wollte auch sicherstellen, dass es false zurückgibt, wenn die Zeichenfolge leer oder null ist. TryParse gibt in diesem Fall true zurück (eine leere Zeichenfolge verursacht beim Parsen als Zahl keinen Fehler). Also, 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 benutzen:

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

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

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

Oder um eine mögliche Hex-Zeichenfolge zu testen, können Sie Folgendes verwenden:

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

Der optionale Parameter 'culture' kann auf die gleiche Weise verwendet werden.

Es ist begrenzt, weil es nicht möglich ist, Zeichenfolgen zu konvertieren, die zu groß sind, um in einem Double enthalten zu sein. Dies ist jedoch eine begrenzte Anforderung, und ich denke, wenn Sie mit Zahlen arbeiten, die größer sind, müssen Sie wahrscheinlich zusätzliche spezialisierte Zahlen verarbeiten funktioniert sowieso.

14
cyberspy

Wenn Sie ein breiteres Spektrum von Zahlen erfassen möchten, können Sie à la PHPs is_numeric 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 );
}

Gerätetest:

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 );
}

Bedenken Sie, dass ein numerischer Wert nicht in einen numerischen Typ konvertiert werden kann. Beispielsweise ist "999999999999999999999999999999.9999999999" ein perfekt gültiger numerischer Wert, der jedoch nicht in einen numerischen .NET-Typ passt (dh keinen, der in der Standardbibliothek definiert ist).

12
JDB

Wenn Sie überprüfen möchten, ob es sich bei einer Zeichenfolge um eine Zahl handelt (ich gehe davon aus, dass es sich um eine Zeichenfolge handelt, da Sie wissen, dass es sich um eine Zahl handelt).

  • Ohne Regex und
  • verwenden Sie den Code von Microsoft so oft wie möglich

sie könnten auch tun:

public static bool IsNumber(this string aNumber)
{
     BigInteger temp_big_int;
     var is_number = BigInteger.TryParse(aNumber, out temp_big_int);
     return is_number;
}

Dies erledigt die üblichen Probleme:

  • Minus (-) oder Plus (+) am Anfang
  • enthält Dezimalzeichen BigInteger analysieren keine Zahlen mit Dezimalstellen. (Also: BigInteger.Parse("3.3") löst eine Ausnahme aus, und TryParse gibt für dasselbe false zurück.)
  • keine lustigen ziffern
  • deckt Fälle ab, in denen die Anzahl größer ist als die übliche Verwendung von Double.TryParse

Du musst einen Verweis auf System.Numerics hinzufügen und using System.Numerics; über deiner Klasse haben (nun, der zweite ist ein Bonus, denke ich :)

9
Noctis

Mit TryParse können Sie bestimmen, ob die Zeichenfolge in eine Ganzzahl zerlegt werden kann.

int i;
bool bNum = int.TryParse(str, out i);

Der Boolesche Wert gibt an, ob es funktioniert hat oder nicht.

9
Craig

Ich denke, diese Antwort geht nur zwischen all den anderen verloren, aber wie auch immer, hier ist es.

Ich bin über Google auf diese Frage gestoßen, weil ich überprüfen wollte, ob ein stringnumeric ist, damit ich nur double.Parse("123") anstelle der TryParse() -Methode verwenden kann.

Warum? Weil es ärgerlich ist, eine Variable out deklarieren zu müssen und das Ergebnis von TryParse() zu überprüfen, bevor Sie wissen, ob die Analyse fehlgeschlagen ist oder nicht. Ich möchte den ternary operator verwenden, um zu überprüfen, ob der stringnumerical ist, und ihn dann einfach im ersten ternären Ausdruck analysieren oder einen Standardwert im zweiten ternären Ausdruck bereitstellen.

So was:

var doubleValue = IsNumeric(numberAsString) ? double.Parse(numberAsString) : 0;

Es ist viel sauberer als:

var doubleValue = 0;
if (double.TryParse(numberAsString, out doubleValue)) {
    //whatever you want to do with doubleValue
}

Ich habe ein paar extension methods für diese Fälle gemacht:


Verlängerungsmethode eins

public static bool IsParseableAs<TInput>(this string value) {
    var type = typeof(TInput);

    var tryParseMethod = type.GetMethod("TryParse", BindingFlags.Static | BindingFlags.Public, Type.DefaultBinder,
        new[] { typeof(string), type.MakeByRefType() }, null);
    if (tryParseMethod == null) return false;

    var arguments = new[] { value, Activator.CreateInstance(type) };
    return (bool) tryParseMethod.Invoke(null, arguments);
}

Beispiel:

"123".IsParseableAs<double>() ? double.Parse(sNumber) : 0;

Da IsParseableAs() versucht, die Zeichenfolge als geeigneten Typ zu analysieren, anstatt nur zu prüfen, ob die Zeichenfolge "numerisch" ist, sollte dies ziemlich sicher sein. Sie können es auch für nicht numerische Typen verwenden, die über eine TryParse() -Methode verfügen, z. B. DateTime.

Die Methode verwendet Reflection und Sie rufen die TryParse() -Methode am Ende zweimal auf, was natürlich nicht so effizient ist, aber nicht alles muss vollständig optimiert werden, manchmal ist Bequemlichkeit einfach wichtiger.

Diese Methode kann auch verwendet werden, um eine Liste mit numerischen Zeichenfolgen auf einfache Weise in eine Liste mit double oder einem anderen Typ mit einem Standardwert zu analysieren, ohne Ausnahmen abfangen zu müssen:

var sNumbers = new[] {"10", "20", "30"};
var dValues = sNumbers.Select(s => s.IsParseableAs<double>() ? double.Parse(s) : 0);

Verlängerungsmethode zwei

public static TOutput ParseAs<TOutput>(this string value, TOutput defaultValue) {
    var type = typeof(TOutput);

    var tryParseMethod = type.GetMethod("TryParse", BindingFlags.Static | BindingFlags.Public, Type.DefaultBinder,
        new[] { typeof(string), type.MakeByRefType() }, null);
    if (tryParseMethod == null) return defaultValue;

    var arguments = new object[] { value, null };
    return ((bool) tryParseMethod.Invoke(null, arguments)) ? (TOutput) arguments[1] : defaultValue;
}

Mit dieser Erweiterungsmethode können Sie string wie type mit einer TryParse() -Methode analysieren und einen Standardwert angeben, der zurückgegeben wird, wenn die Konvertierung fehlschlägt.

Dies ist besser als die Verwendung des ternären Operators mit der obigen Erweiterungsmethode, da die Konvertierung nur einmal ausgeführt wird. Es verwendet immer noch Reflexion obwohl ...

Beispiele:

"123".ParseAs<int>(10);
"abc".ParseAs<int>(25);
"123,78".ParseAs<double>(10);
"abc".ParseAs<double>(107.4);
"2014-10-28".ParseAs<DateTime>(DateTime.MinValue);
"monday".ParseAs<DateTime>(DateTime.MinValue);

Ausgänge:

123
25
123,78
107,4
28.10.2014 00:00:00
01.01.0001 00:00:00

Wenn Sie wissen möchten, ob eine Zeichenfolge eine Zahl ist, können Sie immer versuchen, sie zu analysieren:

var numberString = "123";
int number;

int.TryParse(numberString , out number);

Beachten Sie, dass TryParse ein bool zurückgibt, mit dem Sie überprüfen können, ob Ihre Analyse erfolgreich war.

6
Gabriel Florit

Double.TryParse

bool Double.TryParse(string s, out double result)
6
John Pirie

PDATE von Kunal Noel Answer

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

In diesem Fall haben wir jedoch die Möglichkeit, dass leere Zeichenfolgen diesen Test bestehen. Sie können also:

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

Verwenden Sie diese Erweiterungsmethoden, um klar zu unterscheiden, ob die Zeichenfolge numerisch ist und ob die Zeichenfolge nur 0-9 Ziffern enthält

public static class ExtensionMethods
{
    /// <summary>
    /// Returns true if string could represent a valid number, including decimals and local culture symbols
    /// </summary>
    public static bool IsNumeric(this string s)
    {
        decimal d;
        return decimal.TryParse(s, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.CurrentCulture, out d);
    }

    /// <summary>
    /// Returns true only if string is wholy comprised of numerical digits
    /// </summary>
    public static bool IsNumbersOnly(this string s)
    {
        if (s == null || s == string.Empty)
            return false;

        foreach (char c in s)
        {
            if (c < '0' || c > '9') // Avoid using .IsDigit or .IsNumeric as they will return true for other characters
                return false;
        }

        return true;
    }
}
2
userSteve

Die beste flexible Lösung mit der eingebauten .net-Funktion namens- char.IsDigit. Es funktioniert mit unbegrenzt langen Nummern. Es wird nur true zurückgegeben, wenn jedes Zeichen eine numerische Zahl ist. Ich habe es oft ohne Probleme und mit einer viel einfacheren Lösung verwendet, die ich jemals gefunden habe. Ich habe eine Beispielmethode erstellt. Sie ist einsatzbereit. Zusätzlich habe ich die Validierung für Null- und Leereingaben hinzugefügt. Damit ist die Methode jetzt absolut kugelsicher

public static bool IsNumeric(string strNumber)
    {
        if (string.IsNullOrEmpty(strNumber))
        {
            return false;
        }
        else
        {
            int numberOfChar = strNumber.Count();
            if (numberOfChar > 0)
            {
                bool r = strNumber.All(char.IsDigit);
                return r;
            }
            else
            {
                return false;
            }
        }
    }
2
Liakat Hossain

Mit c # 7 können Sie die Out-Variable inline setzen:

if(int.TryParse(str, out int v))
{
}
2
Chad Kuehn
public static bool IsNumeric(this string input)
{
    int n;
    if (!string.IsNullOrEmpty(input)) //.Replace('.',null).Replace(',',null)
    {
        foreach (var i in input)
        {
            if (!int.TryParse(i.ToString(), out n))
            {
                return false;
            }

        }
        return true;
    }
    return false;
}
2
OMANSAK

Hoffe das hilft

string myString = "abc";
double num;
bool isNumber = double.TryParse(myString , out num);

if isNumber 
{
//string is number
}
else
{
//string is not a number
}
1
Arun

Ziehen Sie einen Verweis auf Visual Basic in Ihr Projekt und verwenden Sie dessen Information.IsNumeric-Methode, wie unten gezeigt, und können Sie sowohl Gleitkommazahlen als auch Ganzzahlen erfassen, im Gegensatz zu der Antwort, bei der nur Ints abgefangen werden.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

    if (Information.IsNumeric(txt))
        Console.WriteLine ("Numeric");

IsNumeric("12.3"); // true
IsNumeric("1"); // true
IsNumeric("abc"); // false
0
ΩmegaMan

Alle Antworten sind nützlich. Bei der Suche nach einer Lösung mit einem numerischen Wert von 12 oder mehr Stellen (in meinem Fall) fand ich beim Debuggen die folgende Lösung hilfreich:

double tempInt = 0;
bool result = double.TryParse("Your_12_Digit_Or_more_StringValue", out tempInt);

Die Ergebnisvariable gibt Ihnen wahr oder falsch.

0
Nayan_07

Probieren Sie die unten stehenden Regeln aus

new Regex(@"^\d{4}").IsMatch("6")    // false
new Regex(@"^\d{4}").IsMatch("68ab") // false
new Regex(@"^\d{4}").IsMatch("1111abcdefg") ```
0
Tahir