Der schnellste Weg, um zu überprüfen, ob die Zeichenfolge nur Ziffern enthält

Ich weiß ein paar Möglichkeiten, wie ich das überprüfen kann. regex, int.parse,tryparse , Looping.

Kann mir jemand sagen, was der schnellste Weg ist, um zu überprüfen?

die Notwendigkeit ist nur zu überprüfen ohne dass eine tatsächliche Analyse .

Dies ist nicht die gleiche Frage wie: Wie identifiziere ich, ob eine Zeichenfolge eine Zahl ist?

Die Frage ist nicht nur, wie man sich identifiziert. aber was ist die schnellste Methode.

bool IsDigitsOnly(string str)
{
    foreach (char c in str)
    {
        if (c < '0' || c > '9')
            return false;
    }

    return true;
}

Wird wahrscheinlich der schnellste Weg sein, dies zu tun.

Hier sind einige Benchmarks, die auf 1000000 Parses derselben Zeichenfolge basieren:

Für releaseStatistiken aktualisiert :

IsDigitsOnly: 384588
TryParse:     639583
Regex:        1329571

Hier ist der Code, sieht aus wie IsDigitsOnly ist schneller:

class Program
{
    private static Regex regex = new Regex("^[0-9]+$", RegexOptions.Compiled);

    static void Main(string[] args)
    {
        Stopwatch watch = new Stopwatch();
        string test = int.MaxValue.ToString();
        int value;

        watch.Start();
        for(int i=0; i< 1000000; i++)
        {
            int.TryParse(test, out value);
        }
        watch.Stop();
        Console.WriteLine("TryParse: "+watch.ElapsedTicks);

        watch.Reset();
        watch.Start();
        for (int i = 0; i < 1000000; i++)
        {
            IsDigitsOnly(test);
        }
        watch.Stop();
        Console.WriteLine("IsDigitsOnly: " + watch.ElapsedTicks);

        watch.Reset();
        watch.Start();
        for (int i = 0; i < 1000000; i++)
        {
            regex.IsMatch(test);
        }
        watch.Stop();
        Console.WriteLine("Regex: " + watch.ElapsedTicks);

        Console.ReadLine();
    }

    static bool IsDigitsOnly(string str)
    {
        foreach (char c in str)
        {
            if (c < '0' || c > '9')
                return false;
        }

        return true;
    }
}

Natürlich ist es erwähnenswert, dass TryParse führende / nachfolgende Leerzeichen sowie kulturspezifische Symbole zulässt. Es ist auch auf die Länge der Saite begrenzt.

Sie können dies einfach mit LINQ tun

return str.All(char.IsDigit);

1. .All Gibt true für leere Zeichenfolgen und eine Ausnahme für Nullzeichenfolgen zurück.
2. char.IsDigit gilt für alle Unicode-Zeichen.

Das Zeichen hat bereits eine IsDigit (Zeichen c), die dies tut:

 public static bool IsDigit(char c)
    {
      if (!char.IsLatin1(c))
        return CharUnicodeInfo.GetUnicodeCategory(c) == UnicodeCategory.DecimalDigitNumber;
      if ((int) c >= 48)
        return (int) c <= 57;
      else
        return false;
    }

Sie können dies einfach tun:

var theString = "839278";
bool digitsOnly = theString.All(char.IsDigit);

Kann etwa 20% schneller sein, wenn nur ein Vergleich pro charund foranstelle von foreach:

bool isDigits(string s) 
{ 
    if (s == null || s == "") return false; 

    for (int i = 0; i < s.Length; i++) 
        if ((s[i] ^ '0') > 9) 
            return false; 

    return true; 
}

Zum Testen verwendeter Code (immer Profil, da die Ergebnisse von Hardware, Versionen, Reihenfolge usw. abhängen):

static bool isDigitsFr(string s) { if (s == null || s == "") return false; for (int i = 0; i < s.Length; i++) if (s[i] < '0' || s[i] > '9') return false; return true; }
static bool isDigitsFu(string s) { if (s == null || s == "") return false; for (int i = 0; i < s.Length; i++) if ((uint)(s[i] - '0') > 9) return false; return true; }
static bool isDigitsFx(string s) { if (s == null || s == "") return false; for (int i = 0; i < s.Length; i++) if ((s[i] ^ '0') > 9) return false; return true; }
static bool isDigitsEr(string s) { if (s == null || s == "") return false; foreach (char c in s) if (c < '0' || c > '9') return false; return true; }
static bool isDigitsEu(string s) { if (s == null || s == "") return false; foreach (char c in s) if ((uint)(c - '0') > 9) return false; return true; }
static bool isDigitsEx(string s) { if (s == null || s == "") return false; foreach (char c in s) if ((c ^ '0') > 9) return false; return true; }
static void test()
{
    var w = new Stopwatch(); bool b; var s = int.MaxValue + ""; int r = 12345678*2; var ss = new SortedSet<string>(); //s = string.Concat(Enumerable.Range(0, 127).Select(i => ((char)i ^ '0') < 10 ? 1 : 0));
    w.Restart(); for (int i = 0; i < r; i++) b = s.All(char.IsDigit); w.Stop(); ss.Add(w.Elapsed + ".All .IsDigit"); 
    w.Restart(); for (int i = 0; i < r; i++) b = s.All(c => c >= '0' && c <= '9'); w.Stop(); ss.Add(w.Elapsed + ".All <>"); 
    w.Restart(); for (int i = 0; i < r; i++) b = s.All(c => (c ^ '0') < 10); w.Stop(); ss.Add(w.Elapsed + " .All ^"); 
    w.Restart(); for (int i = 0; i < r; i++) b = isDigitsFr(s); w.Stop(); ss.Add(w.Elapsed + " for     <>");
    w.Restart(); for (int i = 0; i < r; i++) b = isDigitsFu(s); w.Stop(); ss.Add(w.Elapsed + " for     -");
    w.Restart(); for (int i = 0; i < r; i++) b = isDigitsFx(s); w.Stop(); ss.Add(w.Elapsed + " for     ^");
    w.Restart(); for (int i = 0; i < r; i++) b = isDigitsEr(s); w.Stop(); ss.Add(w.Elapsed + " foreach <>");
    w.Restart(); for (int i = 0; i < r; i++) b = isDigitsEu(s); w.Stop(); ss.Add(w.Elapsed + " foreach -");
    w.Restart(); for (int i = 0; i < r; i++) b = isDigitsEx(s); w.Stop(); ss.Add(w.Elapsed + " foreach ^");
    MessageBox.Show(string.Join("\n", ss)); return;
}

Ergebnisse für Intel i5-3470 bei 3,2 GHz, VS 2015 .NET 4.6.1 Freigabemodus und aktivierte Optimierungen:

time    method          ratio
0.7776  for     ^       1.0000 
0.7984  foreach -       1.0268 
0.8066  foreach ^       1.0372 
0.8940  for     -       1.1497 
0.8976  for     <>      1.1543 
0.9456  foreach <>      1.2160 
4.4559  .All <>         5.7303 
4.7791  .All ^          6.1458 
4.8539  .All. IsDigit   6.2421 

Beachten Sie Folgendes, wenn Sie versucht sind, die kürzeren Methoden zu verwenden

• .Allführt truezu leeren Zeichenfolgen und einer Ausnahme für nullZeichenfolgen
• char.IsDigitgilt für alle Unicode-Zeichen in der Kategorie Nd
• int.TryParse erlaubt auch weiße Spase- und Zeichenzeichen

Wenn Sie sich Gedanken über die Leistung machen, verwenden Sie weder int.TryParsenoch Regex- schreiben Sie Ihre eigene (einfache) Funktion ( DigitsOnlyoder DigitsOnly2darunter, aber nicht DigitsOnly3 - LINQ scheint einen erheblichen Overhead zu verursachen).

Beachten Sie auch, dass dies int.TryParsefehlschlägt, wenn die Zeichenfolge zu lang ist, um "hinein zu passen" int.

Dieser einfache Maßstab ...

class Program {

    static bool DigitsOnly(string s) {
        int len = s.Length;
        for (int i = 0; i < len; ++i) {
            char c = s[i];
            if (c < '0' || c > '9')
                return false;
        }
        return true;
    }

    static bool DigitsOnly2(string s) {
        foreach (char c in s) {
            if (c < '0' || c > '9')
                return false;
        }
        return true;
    }

    static bool DigitsOnly3(string s) {
        return s.All(c => c >= '0' && c <= '9');
    }

    static void Main(string[] args) {

        const string s1 = "916734184";
        const string s2 = "916734a84";

        const int iterations = 1000000;
        var sw = new Stopwatch();

        sw.Restart();
        for (int i = 0 ; i < iterations; ++i) {
            bool success = DigitsOnly(s1);
            bool failure = DigitsOnly(s2);
        }
        sw.Stop();
        Console.WriteLine(string.Format("DigitsOnly: {0}", sw.Elapsed));

        sw.Restart();
        for (int i = 0; i < iterations; ++i) {
            bool success = DigitsOnly2(s1);
            bool failure = DigitsOnly2(s2);
        }
        sw.Stop();
        Console.WriteLine(string.Format("DigitsOnly2: {0}", sw.Elapsed));

        sw.Restart();
        for (int i = 0; i < iterations; ++i) {
            bool success = DigitsOnly3(s1);
            bool failure = DigitsOnly3(s2);
        }
        sw.Stop();
        Console.WriteLine(string.Format("DigitsOnly3: {0}", sw.Elapsed));

        sw.Restart();
        for (int i = 0; i < iterations; ++i) {
            int dummy;
            bool success = int.TryParse(s1, out dummy);
            bool failure = int.TryParse(s2, out dummy);
        }
        sw.Stop();
        Console.WriteLine(string.Format("int.TryParse: {0}", sw.Elapsed));

        sw.Restart();
        var regex = new Regex("^[0-9]+$", RegexOptions.Compiled);
        for (int i = 0; i < iterations; ++i) {
            bool success = regex.IsMatch(s1);
            bool failure = regex.IsMatch(s2);
        }
        sw.Stop();
        Console.WriteLine(string.Format("Regex.IsMatch: {0}", sw.Elapsed));

    }

}

... ergibt folgendes Ergebnis ...

DigitsOnly: 00:00:00.0346094
DigitsOnly2: 00:00:00.0365220
DigitsOnly3: 00:00:00.2669425
int.TryParse: 00:00:00.3405548
Regex.IsMatch: 00:00:00.7017648

Ich mag Linq und um es bei der ersten Nichtübereinstimmung zu beenden, können Sie dies tun

string str = '0129834X33';
bool isAllDigits = !str.Any( ch=> ch < '0' || ch > '9' );

Der wahrscheinlich schnellste Weg ist:

myString.All(c => char.IsDigit(c))

Hinweis: Es wird True zurückgegeben, falls Ihre Zeichenfolge leer ist, was falsch ist (wenn Sie leer nicht als gültige Zahl / Ziffer betrachten).

Funktion mit leerer Validierung:

public static bool IsDigitsOnly(string str)
  {             
        return !string.IsNullOrEmpty(str) && str.All(char.IsDigit);
  }

Das sollte funktionieren:

Regex.IsMatch("124", "^[0-9]+$", RegexOptions.Compiled)

int.Parseoder int.TryParsefunktioniert nicht immer, da die Zeichenfolge möglicherweise mehr Ziffern enthält, die ein Int enthalten kann.

Wenn Sie diese Überprüfung mehr als einmal durchführen, ist es nützlich, einen kompilierten regulären Ausdruck zu verwenden. Beim ersten Mal dauert es länger, aber danach ist es viel schneller.

Sie können dies in einer einzeiligen LINQ-Anweisung tun. OK, mir ist klar, dass dies nicht unbedingt der schnellste ist, also beantworte ich die Frage technisch nicht, aber es ist wahrscheinlich am einfachsten zu schreiben:

str.All(c => c >= '0' && c <= '9')

Das könnte sehr spät kommen!, Aber ich bin sicher, es wird jemandem helfen, wie es mir geholfen hat.

        private static bool IsDigitsOnly(string str)
        {
            return str.All(c => c >= '0' && c <= '9');
        }

Sie können versuchen, reguläre Ausdrücke zu verwenden, indem Sie die Eingabezeichenfolge mithilfe der .IsMatch(string input, string pattern)Methode in C # so testen, dass sie nur Ziffern (0-9) enthält .

using System;
using System.Text.RegularExpression;

public namespace MyNS
{
    public class MyClass
    {
        public void static Main(string[] args)
        {
             string input = Console.ReadLine();
             bool containsNumber = ContainsOnlyDigits(input);
        }

        private bool ContainOnlyDigits (string input)
        {
            bool containsNumbers = true;
            if (!Regex.IsMatch(input, @"/d"))
            {
                containsNumbers = false;
            }
            return containsNumbers;
        }
    }
}

Grüße

Dies wird perfekt funktionieren, es gibt viele andere Möglichkeiten, aber dies würde funktionieren

bool IsDigitsOnly(string str)
    {
        if (str.Length > 0)//if contains characters
        {
            foreach (char c in str)//assign character to c
            {
                if (c < '0' || c > '9')//check if its outside digit range
                    return false;
            }
        }else//empty string
        {
            return false;//empty string 
        }

        return true;//only digits
    }

Versuchen Sie diesen Code:

bool isDigitsOnly(string str)
{
   try
   {
      int number = Convert.ToInt32(str);
      return true;
   }
   catch (Exception)
   {
      return false;
   }
}

public bool CheckforDigits(string x)
{    
    int tr;  
    return x.All(r=> int.TryParse(r.ToString(), out tr));
}

Was ist mit char.IsDigit(myChar)?

Sehr clevere und einfache Möglichkeit, Ihre Zeichenfolge zu erkennen, enthält nur Ziffern oder nicht:

string s = "12fg";

if(s.All(char.IsDigit))
{
   return true; // contains only digits
}
else
{
   return false; // contains not only digits
}