Schnellste Möglichkeit zu überprüfen, ob die Zeichenfolge nur Ziffern enthält

Ich kenne ein paar Möglichkeiten, wie Sie dies überprüfen können.
regex -int.parse,tryparselooping.

kann mir jemand sagen, was ist der Schnellste Weg, dies zu überprüfen?

müssen, ist nur ÜBERPRÜFEN keine Notwendigkeit, um tatsächlich zu analysieren.

dies ist nicht die gleiche Frage wie: Wie kann ich feststellen, ob ein string eine Zahl?

die Frage ist nicht nur, wie identifizieren.
aber über das, was der Schnellste Methode.

Kommentar zu dem Problem - Öffnen

w/o genau Messen ich würde vermuten, int.tryparse Kommentarautor: kenny

Wahrscheinlich eine Schleife geschrieben in der Montage, liest native-Wort-große Stücke von Daten aus dem string in ein register und führt dann einen range-check auf jedes byte in das register. Kommentarautor: aroth

einfach return str.Alle(Char.IsDigit); Kommentarautor: Mohsen

int.TryParse nicht überprüfen, ob Zeichenfolge enthält nur Ziffern! Zeichenfolgen wie " -13 " (mit minus-und Leerzeichen) erfolgreich analysiert werden. Kommentarautor: aleyush

Mögliche Duplikate von Wie kann ich feststellen, ob ein string eine Zahl ist? Kommentarautor: Jim Fell

InformationsquelleAutor der Frage Nahum | 2011-09-18

190

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

    return true;
}

Wird wohl der Schnellste Weg, es zu tun.

InformationsquelleAutor der Antwort Janiels

Hier einige benchmarks basierend auf 1000000 analysiert, die von den gleichen string:

Aktualisiert release stats:

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 nicht erlaubt, führende/nachfolgende Leerzeichen sowie kulturspezifische Symbole. Es ist auch begrenzt auf die Länge der Zeichenfolge.

InformationsquelleAutor der Antwort TheCodeKing

Der char hat schon ein IsDigit(char c), die Folgendes 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;
    }

Können Sie einfach, dies zu tun:

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

InformationsquelleAutor der Antwort flayn

18

Können Sie einfach tun dies mit Hilfe von LINQ

return str.All(char.IsDigit);

InformationsquelleAutor der Antwort Uday

Wenn Sie sind besorgt über die Leistung, weder int.TryParse noch Regex - schreiben Sie Ihre eigene (einfache) Funktion (DigitsOnly oder DigitsOnly2 unten, aber nicht DigitsOnly3 - LINQ scheint zu entstehen, eine erhebliche overhead).

Beachten Sie auch, dass int.TryParse wird fehlschlagen, wenn der string zu lang ist "fit" in int.

Diesem einfachen benchmark...

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

    }

}

...führt zu folgendem 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

InformationsquelleAutor der Antwort Branko Dimitrijevic

Werden kann, etwa 20% schneller mit nur einem Vergleich pro char und for statt 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; 
}

Code für die Tests verwendet (immer Profil, weil die Ergebnisse davon abhängen, hardware, Versionen, etc.):

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 auf Intel i5-3470 @ 3.2 GHz, VS 2015 .NET 4.6.1 Release-Modus und Optimierungen aktiviert:

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

Für jemand versucht, verwenden Sie die kürzere Methoden, beachten Sie, dass

.All Ergebnisse in true für leere Saiten und Ausnahme für null strings
char.IsDigit gilt für alle Unicode-Zeichen in der Nd-Kategorie
int.TryParse ermöglicht auch weiß spase und Zeichen Zeichen

InformationsquelleAutor der Antwort Slai

9

Ich wie Linq zu machen, und die Ausfahrt auf die erste Diskrepanz, die Sie tun können diese
```
string str = '0129834X33';
bool isAllDigits = !str.Any( ch=> ch < '0' || ch > '9' );
```
InformationsquelleAutor der Antwort Alobidat
7

Sollte dies funktionieren:
```
Regex.IsMatch("124", "^[0-9]+$", RegexOptions.Compiled)
```
int.Parse oder int.TryParse funktioniert nicht immer, da der string enthält möglicherweise mehr stellen, die ein int aufnehmen kann.

Wenn Sie beabsichtigen, führen Sie diese überprüfung mehr als einmal ist es nützlich, um ein regex kompiliert - es braucht mehr Zeit, der ersten Zeit, ist aber viel schneller nach.

InformationsquelleAutor der Antwort Petar Ivanov
5

Wahrscheinlich der Schnellste Weg ist:
```
myString.All(c => char.IsDigit(c))
```
Hinweis: wird es wieder Wahr im Falle Ihrer Zeichenfolge leer ist, was nicht korrekt ist (wenn Sie nicht in Anbetracht leerer als gültige Zahl/Ziffer )

InformationsquelleAutor der Antwort Atulya
4

Können Sie dies tun, in einer Linie LINQ-Anweisung. OK, ich begreife, das ist nicht unbedingt der Schnellste, also nicht technisch beantworten Sie die Frage, aber es ist wahrscheinlich das einfachste zu schreiben:
```
str.All(c => c >= '0' && c <= '9')
```
InformationsquelleAutor der Antwort Stephen Holt

Können Sie versuchen, mit Regulären Ausdrücken durch die Prüfung der Eingabe-string, der nur zahlen (0-9) mit der .IsMatch(string input, string pattern) Methode in C#.

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

Hinsichtlich

InformationsquelleAutor der Antwort Jason Cidras

dies funktioniert perfekt, es gibt viele andere Möglichkeiten aber diese funktionieren würde

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
    }

InformationsquelleAutor der Antwort Hossein ElDelbani

0

Sehr Clevere und einfache Weise zu erkennen, Ihr string ist enthält nur Ziffern oder nicht, ist auf diese Weise:
```
string s = "12fg";

if(s.All(char.IsDigit))
{
   return true; //contains only digits
}
else
{
   return false; //contains not only digits
}
```
InformationsquelleAutor der Antwort Avtandil Kavrelishvili

Versuchen, diesen code:

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

InformationsquelleAutor der Antwort H. Borsipour

-1

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

InformationsquelleAutor der Antwort ReR

-2

Was char.IsDigit(myChar)?

InformationsquelleAutor der Antwort Mirko

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.