[.net] .NET- “대문자”로 구분 된 문자열을 배열로 분할하려면 어떻게해야합니까?

이 문자열에서 어떻게 이동합니까 : “ThisIsMyCapsDelimitedString”

…이 문자열에 : “This Is My Caps Delimited String”

VB.net의 적은 코드 줄이 선호되지만 C #도 환영합니다.

건배!



답변

나는 이것을 얼마 전에 만들었다. CamelCase 이름의 각 구성 요소와 일치합니다.

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

예를 들면 :

"SimpleHTTPServer" => ["Simple", "HTTP", "Server"]
"camelCase" => ["camel", "Case"]

단어 사이에 공백을 삽입하도록 변환하려면 :

Regex.Replace(s, "([a-z](?=[A-Z])|[A-Z](?=[A-Z][a-z]))", "$1 ")

숫자를 처리해야하는 경우 :

/([A-Z]+(?=$|[A-Z][a-z]|[0-9])|[A-Z]?[a-z]+|[0-9]+)/g

Regex.Replace(s,"([a-z](?=[A-Z]|[0-9])|[A-Z](?=[A-Z][a-z]|[0-9])|[0-9](?=[^0-9]))","$1 ")


답변

Regex.Replace("ThisIsMyCapsDelimitedString", "(\\B[A-Z])", " $1")


답변

좋은 대답, MizardX! “Address Line1″이 “Address Line1″대신 “Address Line 1″이되도록 숫자를 별도의 단어로 처리하도록 약간 조정했습니다.

Regex.Replace(s, "([a-z](?=[A-Z0-9])|[A-Z](?=[A-Z][a-z]))", "$1 ")


답변

약간의 다양성을 위해 … 여기 정규식을 사용하지 않는 확장 방법이 있습니다.

public static class CamelSpaceExtensions
{
    public static string SpaceCamelCase(this String input)
    {
        return new string(Enumerable.Concat(
            input.Take(1), // No space before initial cap
            InsertSpacesBeforeCaps(input.Skip(1))
        ).ToArray());
    }

    private static IEnumerable<char> InsertSpacesBeforeCaps(IEnumerable<char> input)
    {
        foreach (char c in input)
        {
            if (char.IsUpper(c)) 
            { 
                yield return ' '; 
            }

            yield return c;
        }
    }
}


답변

그랜트 와그너의 훌륭한 코멘트는 제쳐두고 :

Dim s As String = RegularExpressions.Regex.Replace("ThisIsMyCapsDelimitedString", "([A-Z])", " $1")


답변

약어와 숫자를 지원하는 솔루션이 필요했습니다. 이 Regex 기반 솔루션은 다음 패턴을 개별 “단어”로 취급합니다.

  • 대문자와 소문자
  • 연속 된 숫자
  • 연속 대문자 (두문자어로 해석 됨)-새 단어는 마지막 대문자를 사용하여 시작할 수 있습니다. 예 : HTMLGuide => “HTML Guide”, “TheATeam”=> “The A Team”

한 줄로 수 있습니다.

Regex.Replace(value, @"(?<!^)((?<!\d)\d|(?(?<=[A-Z])[A-Z](?=[a-z])|[A-Z]))", " $1")

더 읽기 쉬운 접근 방식이 더 좋을 수 있습니다.

using System.Text.RegularExpressions;

namespace Demo
{
    public class IntercappedStringHelper
    {
        private static readonly Regex SeparatorRegex;

        static IntercappedStringHelper()
        {
            const string pattern = @"
                (?<!^) # Not start
                (
                    # Digit, not preceded by another digit
                    (?<!\d)\d 
                    |
                    # Upper-case letter, followed by lower-case letter if
                    # preceded by another upper-case letter, e.g. 'G' in HTMLGuide
                    (?(?<=[A-Z])[A-Z](?=[a-z])|[A-Z])
                )";

            var options = RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled;

            SeparatorRegex = new Regex(pattern, options);
        }

        public static string SeparateWords(string value, string separator = " ")
        {
            return SeparatorRegex.Replace(value, separator + "$1");
        }
    }
}

다음은 (XUnit) 테스트에서 발췌 한 것입니다.

[Theory]
[InlineData("PurchaseOrders", "Purchase-Orders")]
[InlineData("purchaseOrders", "purchase-Orders")]
[InlineData("2Unlimited", "2-Unlimited")]
[InlineData("The2Unlimited", "The-2-Unlimited")]
[InlineData("Unlimited2", "Unlimited-2")]
[InlineData("222Unlimited", "222-Unlimited")]
[InlineData("The222Unlimited", "The-222-Unlimited")]
[InlineData("Unlimited222", "Unlimited-222")]
[InlineData("ATeam", "A-Team")]
[InlineData("TheATeam", "The-A-Team")]
[InlineData("TeamA", "Team-A")]
[InlineData("HTMLGuide", "HTML-Guide")]
[InlineData("TheHTMLGuide", "The-HTML-Guide")]
[InlineData("TheGuideToHTML", "The-Guide-To-HTML")]
[InlineData("HTMLGuide5", "HTML-Guide-5")]
[InlineData("TheHTML5Guide", "The-HTML-5-Guide")]
[InlineData("TheGuideToHTML5", "The-Guide-To-HTML-5")]
[InlineData("TheUKAllStars", "The-UK-All-Stars")]
[InlineData("AllStarsUK", "All-Stars-UK")]
[InlineData("UKAllStars", "UK-All-Stars")]


답변

더 다양하게, 일반 오래된 C # 개체를 사용하여 다음은 @MizardX의 우수한 정규식과 동일한 출력을 생성합니다.

public string FromCamelCase(string camel)
{   // omitted checking camel for null
    StringBuilder sb = new StringBuilder();
    int upperCaseRun = 0;
    foreach (char c in camel)
    {   // append a space only if we're not at the start
        // and we're not already in an all caps string.
        if (char.IsUpper(c))
        {
            if (upperCaseRun == 0 && sb.Length != 0)
            {
                sb.Append(' ');
            }
            upperCaseRun++;
        }
        else if( char.IsLower(c) )
        {
            if (upperCaseRun > 1) //The first new word will also be capitalized.
            {
                sb.Insert(sb.Length - 1, ' ');
            }
            upperCaseRun = 0;
        }
        else
        {
            upperCaseRun = 0;
        }
        sb.Append(c);
    }

    return sb.ToString();
}