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

Question

Итак, у меня длинная строка цифр, но мне нужно убедиться, что у нее нет цифр, самый простой способ сделать это?

Answer 1

Используйте регулярные выражения:

using System.Text.RegularExpressions; 

string myString = "some long characters..."; 
if(Regex.IsMatch(myString, @"^\d+$", RegexOptions.Compiled)) 
{ 
    // String contains only numbers 
} 
if(Regex.IsMatch(myString, @"^\w+$", RegexOptions.Compiled)) 
{ 
    // String contains only letters 
} 

Answer 2

Вы можете использовать char.IsDigit:

var containsOnlyDigits = "007".All(char.IsDigit); // true 

Answer 3

Попробуйте использовать TryParse

bool longStringisInt = Int64.TryParse(longString, out number); 

Если строка (т.е. longString) не может быть преобразован в межд (т. е. имеет в нем буквы), то bool ложно, иначе это было бы правдой.

EDIT: Изменен Int64 для обеспечения более широкого охвата

Answer 4

Сканирование строки, проверить полукокс ... s.All(c => Char.IsDigit(c))

Enumerable.All выйдет, как только он находит нецифры characted. IsDigit очень быстро проверяет символ. Стоимость - O (N) (насколько это возможно); Конечно, это bettet, чем попытка проанализировать строку (которая не удастся, если строка действительно длинная) или использовать regexpr ...

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

foreach (char c in s) { 
    if (!Char.IsDigit(c)) 
     return false; 
} 
return true; 

или даже лучше:

for (int i = 0; i < s.Length; i++){ 
    if (!Char.IsDigit(s[i])) 
     return false; 
} 
return true; 

---

EDIT: эталоны, наконец!

using System; 
using System.Collections.Generic; 
using System.Diagnostics; 
using System.Linq; 
using System.Text.RegularExpressions; 


namespace FindTest 
{ 
    class Program 
    { 


     const int Iterations = 1000; 

     static string TestData; 
     static Regex regex; 
     static bool ValidResult = false; 


     static void Test(Func<string, bool> function) 
     { 
      Console.Write("{0}... ", function.Method.Name); 
      Stopwatch sw = Stopwatch.StartNew(); 
      for (int i = 0; i < Iterations; i++) 
      { 
       bool result = function(TestData); 
       if (result != ValidResult) 
       { 
        throw new Exception("Bad result: " + result); 
       } 
      } 
      sw.Stop(); 
      Console.WriteLine(" {0}ms", sw.ElapsedMilliseconds); 
      GC.Collect(); 
     } 

     static void InitializeTestDataEnd(int length) 
     { 
      TestData = new string(Enumerable.Repeat('1', length - 1).ToArray()) + "A"; 
     } 

     static void InitializeTestDataStart(int length) 
     { 
      TestData = "A" + new string(Enumerable.Repeat('1', length - 1).ToArray()); 
     } 

     static void InitializeTestDataMid(int length) 
     { 
      TestData = new string(Enumerable.Repeat('1', length/2).ToArray()) + "A" + new string(Enumerable.Repeat('1', length/2 - 1).ToArray()); 
     } 

     static void InitializeTestDataPositive(int length) 
     { 
      TestData = new string(Enumerable.Repeat('1', length).ToArray()); 
     } 

     static bool LinqScan(string s) 
     { 
      return s.All(Char.IsDigit); 
     } 

     static bool ForeachScan(string s) 
     { 
      foreach (char c in s) 
      { 
       if (!Char.IsDigit(c)) 
        return false; 
      } 
      return true; 
     } 

     static bool ForScan(string s) 
     { 
      for (int i = 0; i < s.Length; i++) 
      { 
       if (!Char.IsDigit(s[i])) 
        return false; 
      } 
      return true; 
     } 

     static bool Regexp(string s) 
     { 
      // String contains numbers 
      return regex.IsMatch(s); 

      // String contains letters 
      //return Regex.IsMatch(s, "\\w", RegexOptions.Compiled); 
     } 

     static void Main(string[] args) 
     { 
      regex = new Regex(@"^\d+$", RegexOptions.Compiled); 

      Console.WriteLine("Positive (all digitis)"); 

      InitializeTestDataPositive(100000); 
      ValidResult = true;    

      Test(LinqScan); 
      Test(ForeachScan); 
      Test(ForScan); 
      Test(Regexp); 

      Console.WriteLine("Negative (char at beginning)"); 
      InitializeTestDataStart(100000); 
      ValidResult = false;    

      Test(LinqScan); 
      Test(ForeachScan); 
      Test(ForScan); 
      Test(Regexp); 

      Console.WriteLine("Negative (char at end)"); 
      InitializeTestDataEnd(100000); 
      ValidResult = false; 

      Test(LinqScan); 
      Test(ForeachScan); 
      Test(ForScan); 
      Test(Regexp); 

      Console.WriteLine("Negative (char in middle)"); 
      InitializeTestDataMid(100000); 
      ValidResult = false; 

      Test(LinqScan); 
      Test(ForeachScan); 
      Test(ForScan); 
      Test(Regexp); 

      Console.WriteLine("Done"); 
     } 
    } 
} 

Я дали положительный результат, и три негативы, 1) испытание, которое регулярное выражение является правильным, 2) ищет подтверждения подозреваемого у меня был ...

Мое мнение, что Regexp.IsMatch пришлось сканировать строку, а также, и поэтому кажется: Времена согласуются с сканирований, только 3x хуже:

Positive (all digitis) 
LinqScan... 952ms 
ForeachScan... 1043ms 
ForScan... 869ms 
Regexp... 3074ms 
Negative (char at beginning) 
LinqScan... 0ms 
ForeachScan... 0ms 
ForScan... 0ms 
Regexp... 0ms 
Negative (char at end) 
LinqScan... 921ms 
ForeachScan... 958ms 
ForScan... 867ms 
Regexp... 3986ms 
Negative (char in middle) 
LinqScan... 455ms 
ForeachScan... 476ms 
ForScan... 430ms 
Regexp... 1982ms 

Кредиты: Я заимствовал функцию тестирования от Jon тарелочкам

Выводы: s.All(Char.IsDigit) эффективен и очень прост (в конце концов, это был оригинальный вопрос). Лично я считаю, что это проще, чем регулярные выражения (мне приходилось смотреть на SO, который был правильным, поскольку я не знаком с синтаксисом C# regexp, который является стандартным, но я не знал - и предлагаемое решение было неправильным) , Итак, измеряйте и не верьте в мифы, подобные «LINQ is slow» или «RegExp медленны». В конце концов, они оба подходят для задачи (это действительно зависит от того, что вам нужно для этого), выберите тот, который вы предпочитаете.

Answer 5

Вы можете использовать IndexOfAny

bool containsDigits = mystring.IndexOfAny("".ToCharArray()) != -1; 

В Linq вы бы сделать:

bool containsDigits = mystring.Any(char.IsDigit); 

Edit:

Я приуроченная это и получается решение Linq является медленнее.

Для длины строки 1,000,000 время выполнения составляет ~ 13 мс для решения linq и 1 мс для IndexOfAny.
Для длины строки 10 000 000 время выполнения для Linq все еще ~ 122 мс, тогда как IndexOfAny составляет ~ 18 мс.