Dizenin yalnızca rakam içerip içermediğini kontrol etmenin en hızlı yolu

Bunu kontrol etmenin birkaç yolunu biliyorum. regex, int.parse, tryparse, döngü.

kimse kontrol etmenin en hızlı yolunun ne olduğunu söyleyebilir mi?

sadece ayrıştırmaya gerek kalmadan KONTROL ETMEK gerekir.

Bu şu soru ile aynı değildir: Bir dizenin sayı olup olmadığını nasıl belirleyebilirim?

soru sadece nasıl tanımlanacağı ile ilgili değildir. ancak en hızlı yöntem nedir?

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

    return true;
}

Muhtemelen bunu yapmanın en hızlı yolu olacak.

Aynı dizenin 1000000 ayrışımına dayanan bazı karşılaştırmalar:

releaseİstatistikler için güncellendi :

IsDigitsOnly: 384588
TryParse:     639583
Regex:        1329571

İşte kod, IsDigitsOnly daha hızlı görünüyor:

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

Tabii ki TryParse'ın kültüre özgü sembollerin yanı sıra önde gelen / sondaki boşluklara da izin verdiğini belirtmek gerekir. Ayrıca ipin uzunluğu ile de sınırlıdır.

Bunu sadece LINQ kullanarak yapabilirsiniz

return str.All(char.IsDigit);

1. .All boş dizeler için true ve boş dizeler için istisna döndürür.
2. char.IsDigit tüm Unicode karakterler için geçerlidir.

Karakter, zaten bunu yapan bir IsDigit'e (karakter c) sahiptir:

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

Bunu basitçe yapabilirsiniz:

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

Başına sadece bir karşılaştırma kullanarak daha hızlı% 20 hakkında olabilir charve foryerine 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; 
}

Test için kullanılan kod (sonuçlar donanıma, sürümlere, sıraya vb. Bağlı olduğu için daima profil verin):

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

Intel i5-3470 @ 3.2GHz, VS 2015 .NET 4.6.1 Sürüm modu ve optimizasyonlar etkinleştirildi:

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 

Daha kısa yöntemleri kullanmaya cazip gelen herkes için,

• .Allsonuçlanır trueboş dizeleri ve istisna nulldizeleri
• char.IsDigitNd kategorisindeki tüm Unicode karakterler için geçerlidir
• int.TryParse ayrıca beyaz spase ve işaret karakterlerine izin verir

Performans konusunda endişeleriniz varsa, ne kullanmayın - ne int.TryParsede Regexkendi (basit) fonksiyonunuzu yazın ( DigitsOnlyveya DigitsOnly2aşağıya, ama değil DigitsOnly3 - LINQ önemli bir ek yüke neden görünüyor).

Ayrıca, int.TryParsedize "sığmayacak" kadar uzun olursa başarısız olacağını unutmayın int.

Bu basit kriter ...

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

    }

}

... aşağıdaki sonucu verir ...

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

Boş doğrulama ile fonksiyon:

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

Linq'i seviyorum ve ilk uyumsuzluktan çıkmak için bunu yapabilirsiniz

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

Muhtemelen en hızlı yol:

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

Not: dizenizin boş olması durumunda yanlış olan True değerini döndürür (geçersiz sayı / basamak olarak boş olarak düşünmüyorsanız)

Bu çalışmalı:

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

int.Parseveya int.TryParseher zaman çalışmaz, çünkü dize bir int'in tutabileceği daha fazla rakam içerebilir.

Bu kontrolü bir kereden fazla yapacaksanız, derlenmiş bir normal ifadeyi kullanmak yararlı olacaktır - ilk kez daha fazla zaman alır, ancak bundan sonra çok daha hızlıdır.

Bunu tek satırlık bir LINQ deyiminde yapabilirsiniz. Tamam, bunun mutlaka en hızlı olmadığını fark ediyorum, bu yüzden teknik olarak soruyu cevaplamıyor, ancak muhtemelen en kolayı:

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

Bu çok geç geliyor olabilir!, Ama eminim bana yardım ettiği için birine yardım edecek.

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

.IsMatch(string input, string pattern)C # 'daki yöntemi kullanarak giriş dizesini yalnızca rakamlara (0-9) sahip olacak şekilde test ederek Normal İfadeleri kullanmayı deneyebilirsiniz .

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

Saygılarımızla

bu mükemmel bir şekilde çalışacak, başka birçok yol var ama bu işe yarayacak

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
    }

Bu kodu deneyin:

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

Ne olmuş char.IsDigit(myChar)?

Dizenizi tespit etmenin çok akıllı ve kolay yolu sadece rakam içeriyor mu değil mi:

string s = "12fg";

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