如何检查一个字符串是否包含超过50个字符的单词？

Question

如何检查一个字符串是否包含超过50个字符的单词？

Answer 1

例如，与LINQ：

string toCheck = "your string here"; 
bool isLong = toCheck 
    .Split(new [] { ' ' }, StringSplitOptions.RemoveEmptyEntries) 
    .Any(s => s.Length > 50); 

---

编辑

出于好奇，与人怀疑正则表达式会更快（我以为也是如此），我已经运行一些简单的测试。不得不承认我对结果感到惊讶：

LINQ（或者说，确切地说，string.Split和LINQ）比编译正则表达式和6-30的执行速度要快于未编译正则表达式和6-30。

我下Release模式下运行的各溶液1'000'000迭代中，检查4个采样串：

• 一个与无50个字符+长字
• 一个正好与一个50个字符+长字，在所述串的端
• 一个正好与一个50个字符+长字，在begining字符串的
• 一个具有多个50个字符+长字，字符串

结果在这里可以看到周围蔓延（LINQ VS正则表达式编译）：

LINQ [noLongWords]，百万迭代。结果=假：867 ms

LINQ [oneLongWordAtEnd]，1000000次迭代。结果= True：986 ms

LINQ [oneLongWordAtBeining]，1000000次迭代。结果= True：827 ms

LINQ [manyLongWordsEverywhere]，1000000次迭代。结果=真：2399毫秒

正则表达式[noLongWords]，1000000次迭代。结果=假：16714毫秒

正则表达式[oneLongWordAtEnd]，1000000次迭代。结果=真：14225 ms

正则表达式[oneLongWordAtBeining]，1000000次迭代。结果=真：6483 ms

正则表达式[manyLongWordsEverywhere]，1000000次迭代。结果=真：6675 ms

测试的源代码可用here。

当然，在正常情况下（谁的理智运行1'000'000迭代？），差异是无关紧要的，人们应该更容易/更可维护的解决方案。

Answer 2

取决于你要寻找的，但基本上是标点符号：

string input = "fox jumped over the fence."; 
bool hasLongWord = input.Split(new[] { ' ', ';', '.' }, 
           StringSplitOptions.RemoveEmptyEntries) 
         .Any(word => word.Length > 50); 

Answer 3

义不容辞的正则表达式的答案：

Regex re = new Regex(@"(\w){50,}"); 
re.IsMatch(input); 

PS：虽然我倾向于远离正则表达式了，我觉得在这正则表达式更简单快捷。 @ jimmy_keen的实验

@jimmy_keen后

编辑 - 感谢您的。

我删除了论坛，因为它是不是真的需要和所需要的时间为正则表达式的少得多，以下是编译输出：

更改正则表达式：

Regex regex = new Regex(@"\w{50,}", RegexOptions.Compiled); 

输出：

LINQ [noLongWords]，百万 迭代。结果=假：725 ms

LINQ [oneLongWordAtEnd]，1000000 迭代。结果=真：760 ms

LINQ [oneLongWordAtBeining]，1000000 迭代。结果=真：651毫秒

LINQ [manyLongWordsEverywhere]， 百万迭代。结果=真： 2107 ms

正则表达式[noLongWords]，1000000 迭代。结果=假：2773毫秒

正则表达式[oneLongWordAtEnd]，1000000 迭代。结果=真：7217 ms

正则表达式[oneLongWordAtBeining]，1000000 迭代。结果=真：3279毫秒

正则表达式[manyLongWordsEverywhere]， 百万迭代。结果=真： 3283毫秒

DONE

正则表达式在这种情况下比LINQ慢是为那种令人惊讶，但也许不是，因为我已经被烧毁正则表达式多次。他们是一个伟大的工具，但非常重。在这种情况下，我想正则表达式将能够来稍稍领先LINQ的，但事实并非如此。

稍微复杂一些，但类似的正则表达式中的许多长的单词的情况下优于LINQ：

Regex regex = new Regex(@"[A-Za-z0-9]{50,}", RegexOptions.Compiled); 

LINQ [noLongWords]，百万 迭代。结果=假：611 ms

LINQ [oneLongWordAtEnd]，1000000 迭代。结果=真：642 ms

LINQ [oneLongWordAtBeining]，1000000 迭代。结果=真：549 ms

LINQ [manyLongWordsEverywhere]，1000000 迭代。结果=真：1914 ms

Regex [noLongWords]，1000000 迭代。结果=假：2085毫秒

正则表达式[oneLongWordAtEnd]，1000000 迭代。结果=真：4147毫秒

正则表达式[oneLongWordAtBeining]，1000000 迭代。结果=真：1569 ms

正则表达式[manyLongWordsEverywhere]， 1000000次迭代。结果=真： 1580毫秒

DONE

但我仍然认为，正则表达式，而且simplicty的性能差异开始在100,000次迭代以上可以看出，正则表达式仍然是最好的解决办法这里

Answer 4

Errr ...我不认为你会发现任何快于：

private static Regex rxLongWord = new Regex(@"\w{50,}") ; 
public HasLongWord(string s) 
{ 
    bool foundLongWord = rxLongWord.IsMatch(s) ; 
    return foundLongWord ; 
}