Cara tercepat untuk memeriksa apakah string hanya berisi digit

Saya tahu beberapa cara bagaimana memeriksanya. regex int.parse,,tryparse , perulangan.

Adakah yang bisa memberi tahu saya apa cara tercepat untuk memeriksa?

yang perlu hanya PERIKSA tidak perlu benar-benar parse.

ini bukan pertanyaan yang sama dengan: Bagaimana cara mengidentifikasi jika string adalah angka?

pertanyaannya bukan hanya tentang bagaimana mengidentifikasi. tetapi tentang apa metode tercepat .

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

    return true;
}

Mungkin akan menjadi cara tercepat untuk melakukannya.

Berikut adalah beberapa tolok ukur berdasarkan 1000000 parses dari string yang sama:

Diperbarui untuk releasestatistik:

IsDigitsOnly: 384588
TryParse:     639583
Regex:        1329571

Berikut kodenya, sepertinya IsDigitsOnly lebih cepat:

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

Tentu saja patut dicatat bahwa TryParse mengizinkan spasi putih terkemuka / tambahan serta simbol spesifik budaya. Ini juga terbatas pada panjang tali.

Anda bisa melakukannya dengan menggunakan LINQ

return str.All(char.IsDigit);

1. .All mengembalikan true untuk string kosong dan pengecualian untuk string null.
2. char.IsDigit ini berlaku untuk semua karakter Unicode.

Char sudah memiliki IsDigit (char c) yang melakukan ini:

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

Anda bisa melakukan ini:

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

Dapat sekitar 20% lebih cepat dengan menggunakan hanya satu perbandingan per chardan forbukannya 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; 
}

Kode yang digunakan untuk pengujian (selalu profil karena hasilnya tergantung pada perangkat keras, versi, pesanan, dll.):

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

Hasil pada Intel i5-3470 @ 3.2GHz, VS 2015 .NET 4.6.1 Mode rilis dan pengoptimalan diaktifkan:

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 

Bagi siapa pun yang tergoda untuk menggunakan metode yang lebih pendek, perhatikan itu

• .Allmenghasilkan truestring kosong dan pengecualian untuk nullstring
• char.IsDigitberlaku untuk semua karakter Unicode dalam kategori Nd
• int.TryParse juga memungkinkan spase putih dan karakter tanda

Jika Anda khawatir tentang kinerja, int.TryParsejangan gunakan atau Regextulis fungsi Anda sendiri (sederhana) ( DigitsOnlyatau di DigitsOnly2bawah, tetapi tidak DigitsOnly3 - LINQ tampaknya mengeluarkan overhead yang signifikan).

Perlu diketahui juga bahwa int.TryParseakan gagal jika string terlalu panjang untuk "cocok"int .

Tolok ukur sederhana ini ...

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

    }

}

... menghasilkan hasil berikut ...

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

Fungsi dengan validasi kosong:

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

Saya suka Linq dan untuk membuatnya keluar pada ketidakcocokan pertama Anda bisa melakukan ini

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

Mungkin cara tercepat adalah:

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

Catatan: itu akan mengembalikan True jika string Anda kosong yang tidak benar (jika Anda tidak menganggap kosong sebagai angka / digit yang valid)

Ini seharusnya bekerja:

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

int.Parse atau int.TryParse tidak akan selalu berfungsi, karena string mungkin berisi lebih banyak digit yang dapat disimpan oleh suatu int.

Jika Anda akan melakukan pemeriksaan ini lebih dari sekali, berguna untuk menggunakan regex yang dikompilasi - ini membutuhkan lebih banyak waktu pertama kali, tetapi jauh lebih cepat setelah itu.

Anda dapat melakukan ini dalam pernyataan LINQ satu baris. OK, saya menyadari ini belum tentu yang tercepat, jadi tidak secara teknis menjawab pertanyaan, tetapi mungkin yang paling mudah untuk ditulis:

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

Ini mungkin datang sangat terlambat !, tapi saya yakin itu akan membantu seseorang, karena itu membantu saya.

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

Anda dapat mencoba menggunakan Ekspresi Reguler dengan menguji string input hanya memiliki digit (0-9) dengan menggunakan .IsMatch(string input, string pattern)metode dalam 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;
        }
    }
}

Salam

ini akan bekerja dengan sempurna, ada banyak cara lain tetapi ini akan berhasil

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
    }

Coba kode ini:

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

Bagaimana dengan char.IsDigit(myChar)?

Cara yang sangat cerdik dan mudah mendeteksi string Anda hanya mengandung digit atau tidak, dengan cara ini:

string s = "12fg";

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