忽略現有空格將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(); 
    } 
}