Самый быстрый способ проверить, содержит ли строка только цифры

Я знаю несколько способов, как это проверить. регулярное выражение, int.parse tryparse, зацикливание.

может ли кто-нибудь сказать мне, что является самым быстрым способом проверки?

нужно только ПРОВЕРИТЬ, чтобы не анализировать.

Это не тот вопрос, что: Как определить, является ли строка числом?

возникает вопрос не только о том, как идентифицировать. но о том, что такое самый быстрый метод.

Ответ 1

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

    return true;
}

Скорее всего, это самый быстрый способ сделать это.

Ответ 2

Вот некоторые тесты, основанные на 1000000 парсерах одной и той же строки:

Обновлено для release stats:

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 позволяет использовать ведущие/конечные пробелы, а также символы, специфичные для культуры. Он также ограничен по длине строки.

Ответ 3

char уже имеет IsDigit (char 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);

Ответ 4

Вы можете просто сделать это с помощью LINQ

return str.All(char.IsDigit);

.All возвращает true для пустых строк и исключений для нулевых строк.
char.IsDigit верен для всех символов Юникода.

Ответ 5

Может быть примерно на 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 Режим деблокирования и оптимизации:

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 верно для всех Юникод символов в категории Nd
int.TryParse также позволяет использовать символы белого и знакового символа

Ответ 6

Если вас беспокоит производительность, не используйте ни 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

Ответ 7

Мне нравится Linq и для его выхода из первого несоответствия вы можете это сделать

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

Ответ 8

Это должно работать:

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

int.Parse или int.TryParse не всегда будет работать, потому что строка может содержать больше цифр, которые может содержать int.

Если вы собираетесь делать эту проверку несколько раз, полезно использовать скомпилированное регулярное выражение - это занимает больше времени в первый раз, но после этого намного быстрее.

Ответ 9

Возможно, самый быстрый способ:

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

Примечание: он вернет True, если ваша строка пуста, которая является неправильной (если вы не считаете пустое действительным число/цифру)

Ответ 10

Вы можете сделать это в одной строке оператора LINQ. Хорошо, я понимаю, что это не обязательно самый быстрый, так что технически не отвечает на этот вопрос, но, наверное, проще всего написать:

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

Ответ 11

Вы можете попробовать использовать регулярные выражения, проверив входную строку, чтобы иметь только цифры (0-9), используя метод .IsMatch(string input, string pattern) в С#.

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

Привет

Ответ 12

это будет работать отлично, есть много других способов, но это сработает

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
    }

Ответ 13

Попробуйте этот код:

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

Ответ 14

Возможно, это будет очень поздно !, но я уверен, что это поможет кому-то, так как это помогло мне.

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

Ответ 15

Функция с пустой проверкой:

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

Ответ 16

Очень умный и простой способ обнаружения вашей строки содержит только цифры или нет:

string s = "12fg";

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

Ответ 17

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

Ответ 18

Как насчет char.IsDigit(myChar)?