วิธีที่เร็วที่สุดในการตรวจสอบว่าสตริงมีตัวเลขเท่านั้นหรือไม่

ฉันรู้วิธีตรวจสอบสิ่งนี้ regex, int.parse, tryparse, บ่วง

ใครสามารถบอกฉันได้ว่าเป็นวิธีที่เร็วที่สุดในการตรวจสอบคืออะไร

ความต้องการคือการตรวจสอบเท่านั้นไม่จำเป็นต้องแยกวิเคราะห์จริง

นี่ไม่ใช่คำถามเดียวกันกับ: ฉันจะระบุได้อย่างไรว่าสตริงเป็นตัวเลข?

คำถามไม่เพียงเกี่ยวกับวิธีการระบุ แต่เกี่ยวกับวิธีที่เร็วที่สุดคืออะไร

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

    return true;
}

อาจเป็นวิธีที่เร็วที่สุดที่จะทำ

ต่อไปนี้เป็นเกณฑ์มาตรฐานบางส่วนจาก 1000000 parses ของสตริงเดียวกัน:

อัปเดตสำหรับreleaseสถิติ:

IsDigitsOnly: 384588
TryParse:     639583
Regex:        1329571

นี่คือรหัสดูเหมือน IsDigitsOnly เร็วกว่า:

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

แน่นอนว่ามันเป็นเรื่องที่น่าสังเกตว่า TryParse นั้นอนุญาตให้มีช่องว่างนำหน้า / ต่อท้ายรวมถึงสัญลักษณ์เฉพาะวัฒนธรรม นอกจากนี้ยังมีข้อ จำกัด เกี่ยวกับความยาวของสตริง

คุณสามารถทำได้โดยใช้ LINQ

return str.All(char.IsDigit);

1. .All ส่งคืน true สำหรับสตริงว่างและข้อยกเว้นสำหรับสตริง null
2. char.IsDigit เป็นจริงสำหรับอักขระ Unicode ทั้งหมด

ถ่านมี IsDigit (ถ่าน c) อยู่แล้วซึ่งทำสิ่งนี้:

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

คุณสามารถทำได้:

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

สามารถเร็วขึ้นประมาณ 20% โดยใช้การเปรียบเทียบเพียงครั้งเดียวต่อครั้งcharและforแทน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; 
}

รหัสที่ใช้สำหรับการทดสอบ (โปรไฟล์เสมอเนื่องจากผลลัพธ์ขึ้นอยู่กับฮาร์ดแวร์รุ่นคำสั่ง ฯลฯ ):

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 โหมด Release และเปิดใช้งานการปรับให้เหมาะสม:

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 

สำหรับผู้ที่ต้องการใช้วิธีที่สั้นกว่านั้นโปรดทราบว่า

• .Allผลลัพธ์ในtrueสำหรับสตริงว่างและข้อยกเว้นสำหรับnullสตริง
• char.IsDigitเป็นจริงสำหรับอักขระ Unicodeทั้งหมดในหมวดหมู่ Nd
• int.TryParse ยังช่วยให้สแป๊ชสีขาวและตัวอักษรลงชื่อ

หากคุณกังวลเกี่ยวกับประสิทธิภาพการทำงานอย่าใช้int.TryParseหรือRegex- เขียนฟังก์ชั่น (ง่าย) ของคุณเอง ( DigitsOnlyหรือ DigitsOnly2ด้านล่าง) แต่ไม่ใช่ DigitsOnly3 - LINQ ดูเหมือนจะมีค่าใช้จ่ายที่สำคัญ)

และโปรดระวังด้วยว่าint.TryParseจะล้มเหลวหากสตริงยาวเกินไปที่จะ "พอดี"intลงใน

มาตรฐานที่เรียบง่ายนี้ ...

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

    }

}

... สร้างผลลัพธ์ต่อไปนี้ ...

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

ฟังก์ชั่นที่มีการตรวจสอบที่ว่างเปล่า:

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

ฉันชอบ Linq และเพื่อให้มันออกจากการจับคู่ครั้งแรกคุณสามารถทำได้

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

อาจเป็นวิธีที่เร็วที่สุดคือ:

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

หมายเหตุ:มันจะกลับมาจริงในกรณีที่สตริงของคุณว่างเปล่าซึ่งไม่ถูกต้อง (หากคุณไม่ได้พิจารณาว่าว่างเปล่าเป็นตัวเลข / หลักที่ถูกต้อง)

สิ่งนี้น่าจะใช้ได้:

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

int.Parseหรือint.TryParseไม่สามารถใช้งานได้เสมอเพราะสตริงอาจมีตัวเลขมากกว่าที่ int สามารถถือ

หากคุณจะทำการตรวจสอบนี้มากกว่าหนึ่งครั้งจะเป็นประโยชน์ในการใช้ regex ที่รวบรวม - มันต้องใช้เวลามากขึ้นในครั้งแรก แต่จะเร็วกว่ามากหลังจากนั้น

คุณสามารถทำได้ในหนึ่งบรรทัดคำสั่ง LINQ ตกลงฉันรู้ว่านี่ไม่จำเป็นต้องเร็วที่สุดดังนั้นจึงไม่ตอบคำถามทางเทคนิค แต่อาจเป็นวิธีที่ง่ายที่สุดในการเขียน:

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

นี่อาจจะช้าไป! แต่ฉันแน่ใจว่ามันจะช่วยใครซักคนเพราะมันช่วยฉันได้

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

คุณสามารถลองใช้นิพจน์ปกติได้โดยทดสอบสตริงอินพุตให้มีเฉพาะตัวเลข (0-9) โดยใช้.IsMatch(string input, string pattern)วิธีการใน 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;
        }
    }
}

ความนับถือ

นี้จะทำงานได้อย่างสมบูรณ์แบบมีหลายวิธี แต่จะทำงานได้

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
    }

ลองรหัสนี้:

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

เกี่ยวกับchar.IsDigit(myChar)อะไร

วิธีที่ชาญฉลาดและง่ายต่อการตรวจสอบสตริงของคุณมีตัวเลขเท่านั้น

string s = "12fg";

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