在将 CamelCase 转换为带空格的字符串时忽略现有空格

Question

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

到目前为止，我有：

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

它适用于将“TestWord”转换为“Test Word”并保持单个单词不变，例如Testing 仍然是 Testing。

但是，当我更喜欢 ABC Test 时，ABCTest 会转换为 A B C 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 problem: IsMatch method never returns
• 上面的正则表达式不会处理美妙的 unicode 世界 - 例如西里尔字母 (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();
    }
}