忽略现有空格将CamelCase转换为空格字符串

Question

我想将camelCase或PascalCase单词分隔为单独的单词集合。

到目前为止，我有：

Regex.Replace(value, @"(\B[A-Z]+?(?=[A-Z][^A-Z])|\B[A-Z]+?(?=[^A-Z]))", " $0", RegexOptions.Compiled); 

它工作正常的转换“TestWord”到“测试字”和离开单个词不变，例如Testing仍为Testing。

但是，ABCTest得到转换为A B C Test时，我更喜欢ABC Test。

Answer 1

尝试：

[A-Z][a-z]+|[A-Z]+(?=[A-Z][a-z])|[a-z]+|[A-Z]+ 

An example on Regex101

---

它是如何在CS中使用？

string strText = " TestWord asdfDasdf ABCDef"; 

string[] matches = Regex.Matches(strText, @"[A-Z][a-z]+|[A-Z]+(?=[A-Z][a-z])|[a-z]+|[A-Z]+") 
       .Cast<Match>() 
       .Select(m => m.Value) 
       .ToArray(); 

string result = String.Join(" ", matches); 

result = 'Test Word asdf Dasdf ABC Def'

---

它是如何工作

在这个例子中的字符串：

TestWord qwerDasdf 
ABCTest Testing ((*&^%$CamelCase!"£$%^^)) 
asdfAasdf 
AaBbbCD 

[A-Z][a-z]+比赛：

• [0-4] Test
• [4-8] Word
• [13-18] Dasdf
• [22-26] Test
• [27-34] Testing
• [45 -50] Camel
• [50-54] Case
• [68-73] Aasdf
• [74-76] Aa
• [76-79] Bbb

[A-Z]+(?=[A-Z][a-z])匹配：

• [19-22] ABC

[a-z]+匹配：

• [9-13] qwer
• [64-68] asdf

[A-Z]+比赛：

• [79-81] CD

Answer 2

这里是我的尝试：

(?<!^|\b|\p{Lu})\p{Lu}+(?=\p{Ll}|\b)|(?<!^\p{Lu}*|\b)\p{Lu}(?=\p{Ll}|(?<!\p{Lu}*)\b) 

该正则表达式可与Regex.Replace和$0一起用作替换字符串。

Regex.Replace(value, @"(?<!^|\b|\p{Lu})\p{Lu}+(?=\p{Ll}|\b)|(?<!^\p{Lu}*|\b)\p{Lu}(?=\p{Ll}|(?<!\p{Lu}*)\b)", " $0", RegexOptions.Compiled); 

见demo

正则表达式说明：

• 包含2层的替代品，以考虑之前或之后小写字母大写字母链。
• (?<!^|\b|\p{Lu})\p{Lu}+(?=\p{Ll}|\b) - 匹配未被前面有串字边界或其他大写字母的开始，而之后是小写字母或单词边界几个大写字母第一替代方案，
• (?<!^\p{Lu}*|\b)\p{Lu}(?=\p{Ll}|(?<!\p{Lu}*)\b) - 第二个选择匹配单个大写字母，该大写字母前面没有以紧跟可选大写字母的字符串开头，或者字边界，后面跟着小写字母或没有可选大写字母的单词边界。

Answer 3

您是否有使用Regex的要求？说实话，我根本不会使用Regex。它们很难调试，并且不易读取。

• 你有时也结束了，像这样的种种乐趣：Regex problem: IsMatch method never returns
• 正则表达式上面不会处理的Unicode的精彩世界 - 例如Cyrillics（http://en.wikipedia.org/wiki/Cyrillic_script）（不是您的具体问题领域可能需要这一点，但为了完整性......）

我会用一个小的，可重复使用，易于测试的扩展方法去：

class Program 
{ 
    static void Main(string[] args) 
    { 
     string[] inputs = new[] 
     { 
      "ABCTest", 
      "HelloWorld", 
      "testTest$Test", 
      "aaҚbb" 
     }; 

     var output = inputs.Select(x => x.SplitWithSpaces(CultureInfo.CurrentUICulture)); 

     foreach (string x in output) 
     { 
      Console.WriteLine(x); 
     } 

     Console.Read(); 
    } 
} 

public static class StringExtensions 
{ 
    public static bool IsLowerCase(this TextInfo textInfo, char input) 
    { 
     return textInfo.ToLower(input) == input; 
    } 

    public static string SplitWithSpaces(this string input, CultureInfo culture = null) 
    { 
     if (culture == null) 
     { 
      culture = CultureInfo.InvariantCulture; 
     } 
     TextInfo textInfo = culture.TextInfo; 

     StringBuilder sb = new StringBuilder(input); 

     for (int i = 1; i < sb.Length; i++) 
     { 
      int previous = i - 1; 

      if (textInfo.IsLowerCase(sb[previous])) 
      { 
       int insertLocation = previous - 1; 

       if (insertLocation > 0) 
       { 
        sb.Insert(insertLocation, ' '); 
       } 

       while (i < sb.Length && textInfo.IsLowerCase(sb[i])) 
       { 
        i++; 
       } 
      }     
     } 

     return sb.ToString(); 
    } 
}