Разделите строку PascalCase на отдельные слова

Question

Я ищу способ разделить строки PascalCase, например. «MyString», в отдельные слова - «My», «String». Другой пользователь posed the question for bash, но я хочу знать, как это сделать с помощью обычных регулярных выражений или, по крайней мере, в .NET.

Бонус, если вы можете найти способ также разделить (и, возможно, заглавные) строки camelCase: например. «myString» становится «my» и «String», с возможностью делать заглавные буквы или строчные строки либо или обе строки.

Answer 1

См. Этот вопрос: Is there a elegant way to parse a word and add spaces before capital letters? Его принятый ответ охватывает то, что вы хотите, включая цифры и несколько прописных букв подряд. Хотя этот образец имеет слова, начинающиеся в верхнем регистре, это равнозначно, когда первое слово находится в нижнем регистре.

string[] tests = { 
    "AutomaticTrackingSystem", 
    "XMLEditor", 
    "AnXMLAndXSLT2.0Tool", 
}; 


Regex r = new Regex(
    @"(?<=[A-Z])(?=[A-Z][a-z])|(?<=[^A-Z])(?=[A-Z])|(?<=[A-Za-z])(?=[^A-Za-z])" 
); 

foreach (string s in tests) 
    r.Replace(s, " "); 

выше выход будет:

[Automatic][Tracking][System] 
[XML][Editor] 
[An][XML][And][XSLT][2.0][Tool] 

Answer 2

var regex = new Regex("([A-Z]+[^A-Z]+)"); 
var matches = regex.Matches("aCamelCaseWord") 
    .Cast<Match>() 
    .Select(match => match.Value); 
foreach (var element in matches) 
{ 
    Console.WriteLine(element); 
} 

Печать

Camel 
Case 
Word 

(Как вы можете видеть, он не обрабатывает верблюжьего. - он упал ведущий "а")

Answer 3

Убедитесь, что не-буквенный символ приходит в начало вашего регулярного выражения с \W и сохраните отдельные строки вместе, затем разделите слова.

Что-то вроде: \W([A-Z][A-Za-z]+)+

Для: sdcsds sd aCamelCaseWord as dasd as aSscdcacdcdc PascelCase DfsadSsdd sd Выходы:

48: PascelCase 
59: DfsadSsdd 

Answer 4

В Ruby:

"aCamelCaseWord".split /(?=[[:upper:]])/ 
=> ["a", "Camel", "Case", "Word"] 

Я использую положительный предпросмотр здесь, так что я могу разделить строку прямо перед каждой прописной буквой. Это позволяет мне сохранить и начальную строчную часть.

Answer 5

Answered in a different question:

void Main() 
{ 
    "aCamelCaseWord".ToFriendlyCase().Dump(); 
} 

public static class Extensions 
{ 
    public static string ToFriendlyCase(this string PascalString) 
    { 
     return Regex.Replace(PascalString, "(?!^)([A-Z])", " $1"); 
    } 
} 

a Camel Case Word Выходы (.Dump() просто печатает на консоль).

Answer 6

Как насчет:

static IEnumerable<string> SplitPascalCase(this string text) 
{ 
    var sb = new StringBuilder(); 
    using (var reader = new StringReader(text)) 
    { 
     while (reader.Peek() != -1) 
     { 
      char c = (char)reader.Read(); 
      if (char.IsUpper(c) && sb.Length > 0) 
      { 
       yield return sb.ToString(); 
       sb.Length = 0; 
      } 

      sb.Append(c); 
     } 
    } 

    if (sb.Length > 0) 
     yield return sb.ToString(); 
} 

Answer 7

Просто, чтобы обеспечить альтернативу RegEx и циклических решений все готовые при условии, здесь ответ, используя LINQ, который также обрабатывает футляр для верблюдов и акронимы:

string[] testCollection = new string[] { "AutomaticTrackingSystem", "XSLT", "aCamelCaseWord" }; 
    foreach (string test in testCollection) 
    { 
     // if it is not the first character and it is uppercase 
     // and the previous character is not uppercase then insert a space 
     var result = test.SelectMany((c, i) => i != 0 && char.IsUpper(c) && !char.IsUpper(test[i - 1]) ? new char[] { ' ', c } : new char[] { c }); 
     Console.WriteLine(new String(result.ToArray())); 
    } 

Выхода из этого:

Automatic Tracking System 
XSLT 
a Camel Case Word 

Answer 8

с целями

• а) Создание функции, которая оптимизирует производительность
• б) имеют свой собственный взгляд на CamelCase, в котором капитализированную аббревиатуре не была (я полностью согласен, что это не стандартное определение случая с верблюдом или паскалем, но это не необычное использование): «TestTLAContainingCamelCase» становится «Test TLA Containing Camel Case» (TLA = Three Letter)

поэтому я создал следующий (не регулярное выражение, многословный, но производительность ориентированной) функции

public static string ToSeparateWords(this string value) 
{ 
    if (value==null){return null;} 
    if(value.Length <=1){return value;} 
    char[] inChars = value.ToCharArray(); 
    List<int> uCWithAnyLC = new List<int>(); 
    int i = 0; 
    while (i < inChars.Length && char.IsUpper(inChars[i])) { ++i; } 
    for (; i < inChars.Length; i++) 
    { 
     if (char.IsUpper(inChars[i])) 
     { 
      uCWithAnyLC.Add(i); 
      if (++i < inChars.Length && char.IsUpper(inChars[i])) 
      { 
       while (++i < inChars.Length) 
       { 
        if (!char.IsUpper(inChars[i])) 
        { 
         uCWithAnyLC.Add(i - 1); 
         break; 
        } 
       } 
      } 
     } 
    } 
    char[] outChars = new char[inChars.Length + uCWithAnyLC.Count]; 
    int lastIndex = 0; 
    for (i=0;i<uCWithAnyLC.Count;i++) 
    { 
     int currentIndex = uCWithAnyLC[i]; 
     Array.Copy(inChars, lastIndex, outChars, lastIndex + i, currentIndex - lastIndex); 
     outChars[currentIndex + i] = ' '; 
     lastIndex = currentIndex; 
    } 
    int lastPos = lastIndex + uCWithAnyLC.Count; 
    Array.Copy(inChars, lastIndex, outChars, lastPos, outChars.Length - lastPos); 
    return new string(outChars); 
} 

Что было самым удивительным было тесты производительности. используя 1 000 000 итераций за функцию

regex pattern used = "([a-z](?=[A-Z])|[A-Z](?=[A-Z][a-z]))" 
test string = "TestTLAContainingCamelCase": 
static regex:  13 302ms 
Regex instance: 12 398ms 
compiled regex: 12 663ms 
brent(above):   345ms 
AndyRose:   1 764ms 
DanTao:    995ms 

метод экземпляра Regex был лишь немного быстрее, чем статический метод, даже более миллиона итераций (и я не могу видеть преимущество использования RegexOptions.Compiled флага), и очень сжатый код Дэн Тао был почти таким же быстрым, как мой гораздо менее четкий код!

Answer 9

public static string PascalCaseToSentence(string input) 
    { 
     if (input == null) return ""; 

     string output = Regex.Replace(input, @"(?<=[A-Z])(?=[A-Z][a-z])|(?<=[^A-Z])(?=[A-Z])|(?<=[A-Za-z])(?=[^A-Za-z])", m => " " + m.Value); 
     return output; 
    } 

Основано на ответе Шимми.