Najszybszy sposób sprawdzenia, czy ciąg zawiera tylko cyfry

Znam kilka sposobów, jak to sprawdzić. regex, int.parse, tryparse, zapętlenie.

czy ktoś może mi powiedzieć, jaki jest najszybszy sposób sprawdzenia?

wystarczy tylko SPRAWDZIĆ, a nie trzeba faktycznie analizować.

to nie jest to samo pytanie co: Jak rozpoznać, czy ciąg jest liczbą?

nie chodzi tylko o to, jak zidentyfikować. ale o tym, jaka jest najszybsza metoda.

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

    return true;
}

Prawdopodobnie będzie to najszybszy sposób na zrobienie tego.

Oto kilka testów porównawczych opartych na analizach 1000000 tego samego ciągu:

Zaktualizowano dla releasestatystyk:

IsDigitsOnly: 384588
TryParse:     639583
Regex:        1329571

Oto kod, wygląda na to, że IsDigitsOnly jest szybsze:

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

Oczywiście warto zauważyć, że TryParse dopuszcza początkowe / końcowe białe znaki, a także symbole specyficzne dla kultury. Jest również ograniczona długością sznurka.

Możesz to po prostu zrobić za pomocą LINQ

return str.All(char.IsDigit);

1. .All zwraca true dla pustych ciągów i wyjątek dla ciągów pustych.
2. char.IsDigit jest prawdziwe dla wszystkich znaków Unicode.

Char ma już IsDigit (char c), który robi to:

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

Możesz to po prostu zrobić:

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

Może być około 20% szybsze, używając tylko jednego porównania na chari forzamiast 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; 
}

Kod używany do testowania (zawsze profilowany, ponieważ wyniki zależą od sprzętu, wersji, kolejności itp.):

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

Wyniki dla Intel i5-3470 @ 3,2GHz, VS 2015 .NET 4.6.1 Tryb wydania i włączone optymalizacje:

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 

Każdy, kto ma ochotę skorzystać z krótszych metod, powinien to zauważyć

• .Allskutkuje truepustymi ciągami i wyjątkiem dla nullciągów
• char.IsDigitobowiązuje dla wszystkich znaków Unicode w kategorii Nd
• int.TryParse dopuszcza również białe znaki i znaki znakowe

Jeśli obawiasz się wydajności, nie używaj int.TryParseani Regex- napisz własną (prostą) funkcję ( DigitsOnlylub DigitsOnly2poniżej, ale nie DigitsOnly3 - wydaje się, że LINQ wiąże się ze znacznym narzutem).

Należy również pamiętać, że int.TryParsenie powiedzie się, jeśli ciąg jest zbyt długi, aby „zmieścić się” int.

Ten prosty punkt odniesienia ...

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

    }

}

... daje następujący wynik ...

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

Funkcja z pustą walidacją:

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

Podoba mi się Linq i aby wyjść z pierwszego niedopasowania, możesz to zrobić

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

Prawdopodobnie najszybszym sposobem jest:

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

Uwaga: zwróci True w przypadku, gdy ciąg jest pusty, co jest niepoprawne (jeśli nie uważasz, że pusty jest prawidłowy numer / cyfra)

To powinno działać:

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

int.Parse lub int.TryParse nie zawsze będzie działać, ponieważ ciąg może zawierać więcej cyfr, które może pomieścić int.

Jeśli zamierzasz to zrobić, sprawdź więcej niż raz, przydatne jest użycie skompilowanego wyrażenia regularnego - za pierwszym razem zajmuje to więcej czasu, ale później jest znacznie szybsze.

Możesz to zrobić w jednowierszowej instrukcji LINQ. OK, zdaję sobie sprawę, że to niekoniecznie jest najszybsze, więc technicznie nie odpowiadam na pytanie, ale prawdopodobnie najłatwiej jest napisać:

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

To może nadejść bardzo późno !, ale jestem pewien, że to komuś pomoże, tak jak pomogło mi.

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

Możesz spróbować użyć wyrażeń regularnych, testując ciąg wejściowy, aby zawierał tylko cyfry (0-9) przy użyciu .IsMatch(string input, string pattern)metody w języku 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;
        }
    }
}

pozdrowienia

to zadziała idealnie, jest wiele innych sposobów, ale to zadziała

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
    }

Wypróbuj ten kod:

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

O co chodzi char.IsDigit(myChar)?

Bardzo sprytny i łatwy sposób na wykrycie, że ciąg zawiera tylko cyfry lub nie, jest następujący:

string s = "12fg";

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