대문자 앞에 공백을 추가하십시오
"ThisStringHasNoSpacesButItDoesHaveCapitals"라는 문자열이 주어지면 대문자 앞에 공백을 추가하는 가장 좋은 방법은 무엇입니까? 끝 문자열은 "이 문자열에는 공백이 없지만 대문자가 있습니다"입니다.다음은 RegEx를 사용한 시도입니다.
System.Text.RegularExpressions.Regex.Replace(value, "[A-Z]", " $0")
정규 표현식이 제대로 작동하지만 (Martin Browns 답변에 투표하기까지했지만) 비싸다 (개인적으로 두 문자보다 긴 패턴을 엄청나게 둔다)이 기능
string AddSpacesToSentence(string text, bool preserveAcronyms)
{
if (string.IsNullOrWhiteSpace(text))
return string.Empty;
StringBuilder newText = new StringBuilder(text.Length * 2);
newText.Append(text[0]);
for (int i = 1; i < text.Length; i++)
{
if (char.IsUpper(text[i]))
if ((text[i - 1] != ' ' && !char.IsUpper(text[i - 1])) ||
(preserveAcronyms && char.IsUpper(text[i - 1]) &&
i < text.Length - 1 && !char.IsUpper(text[i + 1])))
newText.Append(' ');
newText.Append(text[i]);
}
return newText.ToString();
}
2,968,750 틱으로 100,000 번, 정규식은 25,000,000 틱 (및 정규식이 컴파일 된 틱)이 걸립니다.주어진 값이 더 좋을수록 (즉 더 빠름) 더 낫지 만 유지해야 할 코드는 더 많습니다. "더 나은"은 종종 경쟁 요구 사항을 타협합니다.도움이 되었기를 바랍니다 :)
업데이트
이것을 본 후 오랜 시간이 걸렸으며 코드가 변경된 후 타이밍이 업데이트되지 않았다는 것을 깨달았습니다 (약간 변경되었습니다).'Abbbbbbbbb'이 100 번 반복 된 문자열 (즉, 1,000 바이트)이있는 문자열에서 100,000 회의 변환은 수작업으로 코딩 된 함수 4,517,177 틱을 취하고 아래의 정규식은 59,435,719를 수행하여 수동으로 코딩 된 함수를 수행하는 시간의 7.6 %에서 실행합니다. 정규식.
업데이트 2
약어를 고려합니까? 지금입니다! if 구문의 논리는 상당히 불분명합니다.
if (char.IsUpper(text[i]))
if (char.IsUpper(text[i - 1]))
if (preserveAcronyms && i < text.Length - 1 && !char.IsUpper(text[i + 1]))
newText.Append(' ');
else ;
else if (text[i - 1] != ' ')
newText.Append(' ');
... 전혀 도움이되지 않습니다!약어에 대해 걱정하지 않는 원래
간단한
방법은 다음과 같습니다.
string AddSpacesToSentence(string text)
{
if (string.IsNullOrWhiteSpace(text))
return "";
StringBuilder newText = new StringBuilder(text.Length * 2);
newText.Append(text[0]);
for (int i = 1; i < text.Length; i++)
{
if (char.IsUpper(text[i]) && text[i - 1] != ' ')
newText.Append(' ');
newText.Append(text[i]);
}
return newText.ToString();
}
솔루션에 첫 번째 문자 T 앞에 공백을 넣는 문제가 있으므로
" This String..." instead of "This String..."
이 문제를 해결하려면 앞에 소문자를 찾은 다음 중간에 공백을 삽입하십시오.
newValue = Regex.Replace(value, "([a-z])([A-Z])", "$1 $2");
편집 1 :
사용
@"(\p{Ll})(\p{Lu})"
하면 악센트 부호가있는 문자도 선택됩니다.
편집 2 :
문자열에 두문자어가 포함될 수있는 경우 다음을 사용할 수 있습니다.
newValue = Regex.Replace(value, @"((?<=\p{Ll})\p{Lu})|((?!\A)\p{Lu}(?>\p{Ll}))", " $0");
따라서 "DriveIsSCSICompatible"은 "Drive Is SCSI Compatible"이됩니다.
성능을 테스트하지는 않았지만 linq와 함께 한 줄로 표시합니다.
var val = "ThisIsAStringToTest";
val = string.Concat(val.Select(x => Char.IsUpper(x) ? " " + x : x.ToString())).TrimStart(' ');
나는 이것이 오래된 것임을 알고 있지만, 이것을해야 할 때 사용하는 확장입니다.
public static class Extensions
{
public static string ToSentence( this string Input )
{
return new string(Input.SelectMany((c, i) => i > 0 && char.IsUpper(c) ? new[] { ' ', c } : new[] { c }).ToArray());
}
}
이것은 당신이 사용할 수 있습니다
MyCasedString.ToSentence()
유니 코드에 오신 것을 환영합니다
이 모든 솔루션은 현대 텍스트에는 본질적으로 잘못되었습니다. 대소 문자를 이해하는 것을 사용해야합니다. Bob이 다른 언어를 요청했기 때문에 Perl에게 몇 가지를 드리겠습니다.최악에서 최고에 이르는 네 가지 솔루션을 제공합니다. 가장 좋은 것만 항상 옳습니다. 다른 사람들에게는 문제가 있습니다. 다음은 작동하는 것과 작동하지 않는 것 및 위치를 보여주는 테스트 실행입니다. 공백을 넣은 위치를 볼 수 있도록 밑줄을 사용했으며, 잘못된 것으로 잘못 표시했습니다.
Testing TheLoneRanger
Worst: The_Lone_Ranger
Ok: The_Lone_Ranger
Better: The_Lone_Ranger
Best: The_Lone_Ranger
Testing MountMᶜKinleyNationalPark
[WRONG] Worst: Mount_MᶜKinley_National_Park
[WRONG] Ok: Mount_MᶜKinley_National_Park
[WRONG] Better: Mount_MᶜKinley_National_Park
Best: Mount_Mᶜ_Kinley_National_Park
Testing ElÁlamoTejano
[WRONG] Worst: ElÁlamo_Tejano
Ok: El_Álamo_Tejano
Better: El_Álamo_Tejano
Best: El_Álamo_Tejano
Testing TheÆvarArnfjörðBjarmason
[WRONG] Worst: TheÆvar_ArnfjörðBjarmason
Ok: The_Ævar_Arnfjörð_Bjarmason
Better: The_Ævar_Arnfjörð_Bjarmason
Best: The_Ævar_Arnfjörð_Bjarmason
Testing IlCaffèMacchiato
[WRONG] Worst: Il_CaffèMacchiato
Ok: Il_Caffè_Macchiato
Better: Il_Caffè_Macchiato
Best: Il_Caffè_Macchiato
Testing MisterDženanLjubović
[WRONG] Worst: MisterDženanLjubović
[WRONG] Ok: MisterDženanLjubović
Better: Mister_Dženan_Ljubović
Best: Mister_Dženan_Ljubović
Testing OleKingHenryⅧ
[WRONG] Worst: Ole_King_HenryⅧ
[WRONG] Ok: Ole_King_HenryⅧ
[WRONG] Better: Ole_King_HenryⅧ
Best: Ole_King_Henry_Ⅷ
Testing CarlosⅤºElEmperador
[WRONG] Worst: CarlosⅤºEl_Emperador
[WRONG] Ok: CarlosⅤº_El_Emperador
[WRONG] Better: CarlosⅤº_El_Emperador
Best: Carlos_Ⅴº_El_Emperador
BTW, 여기에있는 거의 모든 사람들이 "Worst"라고 표시된 첫 번째 방법을 선택했습니다. "OK"라고 표시된 두 번째 방법을 선택한 사람이 있습니다. 그러나 나보다 먼저 "더 나은"또는 "최상의"접근 방식을 수행하는 방법을 보여준 사람은 없습니다.다음은 네 가지 방법으로 테스트 프로그램입니다.
#!/usr/bin/env perl
use utf8;
use strict;
use warnings;
# First I'll prove these are fine variable names:
my (
$TheLoneRanger ,
$MountMᶜKinleyNationalPark ,
$ElÁlamoTejano ,
$TheÆvarArnfjörðBjarmason ,
$IlCaffèMacchiato ,
$MisterDženanLjubović ,
$OleKingHenryⅧ ,
$CarlosⅤºElEmperador ,
);
# Now I'll load up some string with those values in them:
my @strings = qw{
TheLoneRanger
MountMᶜKinleyNationalPark
ElÁlamoTejano
TheÆvarArnfjörðBjarmason
IlCaffèMacchiato
MisterDženanLjubović
OleKingHenryⅧ
CarlosⅤºElEmperador
};
my($new, $best, $ok);
my $mask = " %10s %-8s %s\n";
for my $old (@strings) {
print "Testing $old\n";
($best = $old) =~ s/(?<=\p{Lowercase})(?=[\p{Uppercase}\p{Lt}])/_/g;
($new = $old) =~ s/(?<=[a-z])(?=[A-Z])/_/g;
$ok = ($new ne $best) && "[WRONG]";
printf $mask, $ok, "Worst:", $new;
($new = $old) =~ s/(?<=\p{Ll})(?=\p{Lu})/_/g;
$ok = ($new ne $best) && "[WRONG]";
printf $mask, $ok, "Ok:", $new;
($new = $old) =~ s/(?<=\p{Ll})(?=[\p{Lu}\p{Lt}])/_/g;
$ok = ($new ne $best) && "[WRONG]";
printf $mask, $ok, "Better:", $new;
($new = $old) =~ s/(?<=\p{Lowercase})(?=[\p{Uppercase}\p{Lt}])/_/g;
$ok = ($new ne $best) && "[WRONG]";
printf $mask, $ok, "Best:", $new;
}
이 데이터 세트에서 "최고"와 동일한 점수를 매길 수 있으면 올바르게 수행 한 것입니다. 그때까지, 당신은하지 않았습니다. 여기서 다른 어느 누구도 "Ok"보다 나은 작업을 수행하지 않았으며 대부분 "Worst"를 수행했습니다. 누군가 올바른 ℂ♯ 코드를 게시하기를 기대합니다.StackOverflow의 강조 표시 코드가 다시 비참하게 다루어졌습니다. 그들은 여기에 언급 된 나머지 가난한 접근 방식과 거의 같은 오래된 절름발이를 만들고 있습니다. ASCII를 쉬게하는 데 시간이 오래 걸리지 않습니까? 더 이상 말이 안 돼요, 당신이 가진 모든 척하는 것은 단순히 잘못입니다. 코드가 잘못되었습니다.
이진 걱정의 코드를 기반으로 간단한 확장 방법을 만들어서 약어를 올바르게 처리하고 반복 할 수 있습니다 (이미 단어가 엉망이되지 않습니다). 여기 내 결과가 있습니다.
public static string UnPascalCase(this string text)
{
if (string.IsNullOrWhiteSpace(text))
return "";
var newText = new StringBuilder(text.Length * 2);
newText.Append(text[0]);
for (int i = 1; i < text.Length; i++)
{
var currentUpper = char.IsUpper(text[i]);
var prevUpper = char.IsUpper(text[i - 1]);
var nextUpper = (text.Length > i + 1) ? char.IsUpper(text[i + 1]) || char.IsWhiteSpace(text[i + 1]): prevUpper;
var spaceExists = char.IsWhiteSpace(text[i - 1]);
if (currentUpper && !spaceExists && (!nextUpper || !prevUpper))
newText.Append(' ');
newText.Append(text[i]);
}
return newText.ToString();
}
이 함수가 통과하는 단위 테스트 사례는 다음과 같습니다. tchrist가 제안한 사례의 대부분을이 목록에 추가했습니다. 통과하지 못하는 세 가지 (두 개는 로마 숫자 일뿐입니다)는 주석 처리됩니다.
Assert.AreEqual("For You And I", "ForYouAndI".UnPascalCase());
Assert.AreEqual("For You And The FBI", "ForYouAndTheFBI".UnPascalCase());
Assert.AreEqual("A Man A Plan A Canal Panama", "AManAPlanACanalPanama".UnPascalCase());
Assert.AreEqual("DNS Server", "DNSServer".UnPascalCase());
Assert.AreEqual("For You And I", "For You And I".UnPascalCase());
Assert.AreEqual("Mount Mᶜ Kinley National Park", "MountMᶜKinleyNationalPark".UnPascalCase());
Assert.AreEqual("El Álamo Tejano", "ElÁlamoTejano".UnPascalCase());
Assert.AreEqual("The Ævar Arnfjörð Bjarmason", "TheÆvarArnfjörðBjarmason".UnPascalCase());
Assert.AreEqual("Il Caffè Macchiato", "IlCaffèMacchiato".UnPascalCase());
//Assert.AreEqual("Mister Dženan Ljubović", "MisterDženanLjubović".UnPascalCase());
//Assert.AreEqual("Ole King Henry Ⅷ", "OleKingHenryⅧ".UnPascalCase());
//Assert.AreEqual("Carlos Ⅴº El Emperador", "CarlosⅤºElEmperador".UnPascalCase());
Assert.AreEqual("For You And The FBI", "For You And The FBI".UnPascalCase());
Assert.AreEqual("A Man A Plan A Canal Panama", "A Man A Plan A Canal Panama".UnPascalCase());
Assert.AreEqual("DNS Server", "DNS Server".UnPascalCase());
Assert.AreEqual("Mount Mᶜ Kinley National Park", "Mount Mᶜ Kinley National Park".UnPascalCase());
이진 걱정, 나는 당신의 제안 된 코드를 사용했으며, 약간 좋습니다. 단지 하나의 추가 사항이 있습니다.
public static string AddSpacesToSentence(string text)
{
if (string.IsNullOrEmpty(text))
return "";
StringBuilder newText = new StringBuilder(text.Length * 2);
newText.Append(text[0]);
for (int i = 1; i < result.Length; i++)
{
if (char.IsUpper(result[i]) && !char.IsUpper(result[i - 1]))
{
newText.Append(' ');
}
else if (i < result.Length)
{
if (char.IsUpper(result[i]) && !char.IsUpper(result[i + 1]))
newText.Append(' ');
}
newText.Append(result[i]);
}
return newText.ToString();
}
조건을 추가했습니다
!char.IsUpper(text[i - 1])
. 이로 인해 'AverageNOX'와 같은 것이 'Average NOX'로 바뀌는 버그가 수정되었습니다. 'Average NOX'를 읽어야하므로 분명히 잘못되었습니다.슬프게도 여전히 'FromAStart'라는 텍스트가 있으면 'From AStart'가 표시되는 버그가 있습니다.이것을 고치는 것에 대한 생각이 있습니까?
내 꺼야 :
private string SplitCamelCase(string s)
{
Regex upperCaseRegex = new Regex(@"[A-Z]{1}[a-z]*");
MatchCollection matches = upperCaseRegex.Matches(s);
List<string> words = new List<string>();
foreach (Match match in matches)
{
words.Add(match.Value);
}
return String.Join(" ", words.ToArray());
}
확인은 확인이
되지 않은
문자열의 시작 부분에 공백을 넣어,하지만 당신은
하는
연속 자본 사이에 그들을 가하고. 여기에있는 답변 중 일부는 그러한 요점 중 하나 또는 둘 다를 다루지 않습니다. 정규 표현식 이외의 다른 방법이 있지만, 그것을 사용하려면 다음을 시도하십시오.
Regex.Replace(value, @"\B[A-Z]", " $0")
는
\B
부정 된이다
\b
는 비 단어 경계를 나타냅니다 있도록. 패턴이에서 "Y"와 일치
XYzabc
하지만 in
Yzabc
또는 와는 일치 하지 않음을 의미합니다
X Yzabc
. 약간의 보너스로 공백이있는 문자열에 이것을 사용할 수 있으며 두 배로 늘리지 않습니다.
당신이 가진 것은 완벽하게 작동합니다.
value
이 함수의 반환 값에 다시 할당 해야합니다.
value = System.Text.RegularExpressions.Regex.Replace(value, "[A-Z]", " $0");
SQL로 어떻게 할 수 있습니까?
create FUNCTION dbo.PascalCaseWithSpace(@pInput AS VARCHAR(MAX)) RETURNS VARCHAR(MAX)
BEGIN
declare @output varchar(8000)
set @output = ''
Declare @vInputLength INT
Declare @vIndex INT
Declare @vCount INT
Declare @PrevLetter varchar(50)
SET @PrevLetter = ''
SET @vCount = 0
SET @vIndex = 1
SET @vInputLength = LEN(@pInput)
WHILE @vIndex <= @vInputLength
BEGIN
IF ASCII(SUBSTRING(@pInput, @vIndex, 1)) = ASCII(Upper(SUBSTRING(@pInput, @vIndex, 1)))
begin
if(@PrevLetter != '' and ASCII(@PrevLetter) = ASCII(Lower(@PrevLetter)))
SET @output = @output + ' ' + SUBSTRING(@pInput, @vIndex, 1)
else
SET @output = @output + SUBSTRING(@pInput, @vIndex, 1)
end
else
begin
SET @output = @output + SUBSTRING(@pInput, @vIndex, 1)
end
set @PrevLetter = SUBSTRING(@pInput, @vIndex, 1)
SET @vIndex = @vIndex + 1
END
return @output
END
이 정규식은 모든 대문자 앞에 공백 문자를 배치합니다.
using System.Text.RegularExpressions;
const string myStringWithoutSpaces = "ThisIsAStringWithoutSpaces";
var myStringWithSpaces = Regex.Replace(myStringWithoutSpaces, "([A-Z])([a-z]*)", " $1$2");
"$ 1 $ 2"이면 앞에있는 공간을 염두에두면됩니다.이것이 결과입니다 :
"This Is A String Without Spaces"
@MartinBrown에서 영감을 얻은 Two Lines of Simple Regex는 문자열의 아무 곳이나 Acyronyms를 포함하여 이름을 확인합니다.
public string ResolveName(string name)
{
var tmpDisplay = Regex.Replace(name, "([^A-Z ])([A-Z])", "$1 $2");
return Regex.Replace(tmpDisplay, "([A-Z]+)([A-Z][^A-Z$])", "$1 $2").Trim();
}
replaceAll("(?<=[^^\\p{Uppercase}])(?=[\\p{Uppercase}])"," ");
static string AddSpacesToColumnName(string columnCaption)
{
if (string.IsNullOrWhiteSpace(columnCaption))
return "";
StringBuilder newCaption = new StringBuilder(columnCaption.Length * 2);
newCaption.Append(columnCaption[0]);
int pos = 1;
for (pos = 1; pos < columnCaption.Length-1; pos++)
{
if (char.IsUpper(columnCaption[pos]) && !(char.IsUpper(columnCaption[pos - 1]) && char.IsUpper(columnCaption[pos + 1])))
newCaption.Append(' ');
newCaption.Append(columnCaption[pos]);
}
newCaption.Append(columnCaption[pos]);
return newCaption.ToString();
}
Ruby에서 Regexp를 통해 :
"FooBarBaz".gsub(/(?!^)(?=[A-Z])/, ' ') # => "Foo Bar Baz"
Kevin Strikers의 탁월한 솔루션을 VB로 변환했습니다. .NET 3.5에 잠겨 있기 때문에 IsNullOrWhiteSpace도 작성해야했습니다. 이것은 그의 모든 테스트를 통과합니다.
<Extension()>
Public Function IsNullOrWhiteSpace(value As String) As Boolean
If value Is Nothing Then
Return True
End If
For i As Integer = 0 To value.Length - 1
If Not Char.IsWhiteSpace(value(i)) Then
Return False
End If
Next
Return True
End Function
<Extension()>
Public Function UnPascalCase(text As String) As String
If text.IsNullOrWhiteSpace Then
Return String.Empty
End If
Dim newText = New StringBuilder()
newText.Append(text(0))
For i As Integer = 1 To text.Length - 1
Dim currentUpper = Char.IsUpper(text(i))
Dim prevUpper = Char.IsUpper(text(i - 1))
Dim nextUpper = If(text.Length > i + 1, Char.IsUpper(text(i + 1)) Or Char.IsWhiteSpace(text(i + 1)), prevUpper)
Dim spaceExists = Char.IsWhiteSpace(text(i - 1))
If (currentUpper And Not spaceExists And (Not nextUpper Or Not prevUpper)) Then
newText.Append(" ")
End If
newText.Append(text(i))
Next
Return newText.ToString()
End Function
에 대한 좋은 기회 인 것 같습니다
Aggregate
. 이것은 반드시 빠르지는 않지만 읽을 수 있도록 설계되었습니다.
someString
.Aggregate(
new StringBuilder(),
(str, ch) => {
if (char.IsUpper(ch) && str.Length > 0)
str.Append(" ");
str.Append(ch);
return str;
}
).ToString();
Martin Brown의 답변 외에도 숫자에 문제가있었습니다. 예를 들어 "Location2"또는 "Jan22"는 각각 "Location 2"및 "Jan 22"여야합니다.Martin Brown의 답변을 사용하여이를 수행하는 정규 표현식은 다음과 같습니다.
"((?<=\p{Ll})\p{Lu})|((?!\A)\p{Lu}(?>\p{Ll}))|((?<=[\p{Ll}\p{Lu}])\p{Nd})|((?<=\p{Nd})\p{Lu})"
다음은 각 부분의 의미를 파악하기위한 훌륭한 사이트입니다.
Java 기반 정규 표현식 분석기 (대부분의 .net 정규식에서 작동)
위의 정규 표현식은
\p{Ll}
with
[a-z]
,
\p{Lu}
with with
[A-Z]
및
\p{Nd}
with를 모두 바꾸지 않으면 액션 스크립트 사이트에서 작동하지 않습니다
[0-9]
.
이진 걱정의 제안 및 Richard Priddys의 의견을 바탕으로 한 내 해결책은 다음과 같습니다. 또한 제공된 문자열에 공백이 존재할 수 있으므로 기존 공백 옆에 공백이 추가되지 않습니다.
public string AddSpacesBeforeUpperCase(string nonSpacedString)
{
if (string.IsNullOrEmpty(nonSpacedString))
return string.Empty;
StringBuilder newText = new StringBuilder(nonSpacedString.Length * 2);
newText.Append(nonSpacedString[0]);
for (int i = 1; i < nonSpacedString.Length; i++)
{
char currentChar = nonSpacedString[i];
// If it is whitespace, we do not need to add another next to it
if(char.IsWhiteSpace(currentChar))
{
continue;
}
char previousChar = nonSpacedString[i - 1];
char nextChar = i < nonSpacedString.Length - 1 ? nonSpacedString[i + 1] : nonSpacedString[i];
if (char.IsUpper(currentChar) && !char.IsWhiteSpace(nextChar)
&& !(char.IsUpper(previousChar) && char.IsUpper(nextChar)))
{
newText.Append(' ');
}
else if (i < nonSpacedString.Length)
{
if (char.IsUpper(currentChar) && !char.IsWhiteSpace(nextChar) && !char.IsUpper(nextChar))
{
newText.Append(' ');
}
}
newText.Append(currentChar);
}
return newText.ToString();
}
이 같은 질문에 대답하는 C ++ 함수를 찾는 사람은 다음을 사용할 수 있습니다. 이것은 @Binary Worrier의 답변을 모델로합니다. 이 방법은 약어를 자동으로 유지합니다.
using namespace std;
void AddSpacesToSentence(string& testString)
stringstream ss;
ss << testString.at(0);
for (auto it = testString.begin() + 1; it != testString.end(); ++it )
{
int index = it - testString.begin();
char c = (*it);
if (isupper(c))
{
char prev = testString.at(index - 1);
if (isupper(prev))
{
if (index < testString.length() - 1)
{
char next = testString.at(index + 1);
if (!isupper(next) && next != ' ')
{
ss << ' ';
}
}
}
else if (islower(prev))
{
ss << ' ';
}
}
ss << c;
}
cout << ss.str() << endl;
이 함수에 사용한 테스트 문자열은 다음과 같습니다.
- "helloWorld"-> "hello world"
- "HelloWorld"-> "Hello World"
- "HelloABCWorld"-> "Hello ABC World"
- "HelloWorldABC"-> "Hello World ABC"
- "ABCHelloWorld"-> "ABC Hello World"
- "ABC HELLO WORLD"-> "ABC HELLO WORLD"
- "ABCHELLOWORLD"-> "ABCHELLOWORLD"
- "A"-> "A"
C #을
ASCII 문자로 구성되어 입력 문자열에 대한 솔루션을 제공합니다.
정규식
통합
부정적인 lookbehind
문자열의 시작 부분에 나타납니다 자본 (대문자) 편지를 무시합니다.
를 사용 하여 원하는 문자열을 반환합니다.
도 참조하십시오 .
using System;
using System.Text.RegularExpressions;
public class RegexExample
{
public static void Main()
{
var text = "ThisStringHasNoSpacesButItDoesHaveCapitals";
// Use negative lookbehind to match all capital letters
// that do not appear at the beginning of the string.
var pattern = "(?<!^)([A-Z])";
var rgx = new Regex(pattern);
var result = rgx.Replace(text, " $1");
Console.WriteLine("Input: [{0}]\nOutput: [{1}]", text, result);
}
}
예상 출력 :
Input: [ThisStringHasNoSpacesButItDoesHaveCapitals]
Output: [This String Has No Spaces But It Does Have Capitals]
업데이트 :
약어
(대문자 문자 순서) 도 처리하는 변형이 있습니다 .
및
도 참조하십시오 .
using System;
using System.Text.RegularExpressions;
public class RegexExample
{
public static void Main()
{
var text = "ThisStringHasNoSpacesASCIIButItDoesHaveCapitalsLINQ";
// Use positive lookbehind to locate all upper-case letters
// that are preceded by a lower-case letter.
var patternPart1 = "(?<=[a-z])([A-Z])";
// Used positive lookbehind and lookahead to locate all
// upper-case letters that are preceded by an upper-case
// letter and followed by a lower-case letter.
var patternPart2 = "(?<=[A-Z])([A-Z])(?=[a-z])";
var pattern = patternPart1 + "|" + patternPart2;
var rgx = new Regex(pattern);
var result = rgx.Replace(text, " $1$2");
Console.WriteLine("Input: [{0}]\nOutput: [{1}]", text, result);
}
}
예상 출력 :
Input: [ThisStringHasNoSpacesASCIIButItDoesHaveCapitalsLINQ]
Output: [This String Has No Spaces ASCII But It Does Have Capitals LINQ]
질문은 조금 오래되었지만 요즘 Nuget에는 사람이 읽을 수있는 텍스트로 많은 다른 변환뿐만 아니라 정확하게 수행하는 멋진 라이브러리가 있습니다.GitHub 또는 Nuget 에서
를 확인하십시오 .
예
"PascalCaseInputStringIsTurnedIntoSentence".Humanize() => "Pascal case input string is turned into sentence"
"Underscored_input_string_is_turned_into_sentence".Humanize() => "Underscored input string is turned into sentence"
"Underscored_input_String_is_turned_INTO_sentence".Humanize() => "Underscored input String is turned INTO sentence"
// acronyms are left intact
"HTML".Humanize() => "HTML"
단어 앞에 공백을 넣지 않는보다 철저한 솔루션이 있습니다.
참고 :
여러 정규 표현식을 사용했습니다 (간결하지는 않지만 약어 및 단일 문자를 처리합니다)
Dim s As String = "ThisStringHasNoSpacesButItDoesHaveCapitals"
s = System.Text.RegularExpressions.Regex.Replace(s, "([a-z])([A-Z](?=[A-Z])[a-z]*)", "$1 $2")
s = System.Text.RegularExpressions.Regex.Replace(s, "([A-Z])([A-Z][a-z])", "$1 $2")
s = System.Text.RegularExpressions.Regex.Replace(s, "([a-z])([A-Z][a-z])", "$1 $2")
s = System.Text.RegularExpressions.Regex.Replace(s, "([a-z])([A-Z][a-z])", "$1 $2") // repeat a second time
에서
:
"ThisStringHasNoSpacesButItDoesHaveCapitals"
"IAmNotAGoat"
"LOLThatsHilarious!"
"ThisIsASMSMessage"
아웃
:
"This String Has No Spaces But It Does Have Capitals"
"I Am Not A Goat"
"LOL Thats Hilarious!"
"This Is ASMS Message" // (Difficult to handle single letter words when they are next to acronyms.)
이전의 모든 응답은 너무 복잡해 보였다.나는 대문자와 _이 혼합 된 문자열을 가지고 있었으므로 string.Replace ()를 사용하여 _, ""를 만들고 다음을 사용하여 대문자에 공백을 추가했습니다.
for (int i = 0; i < result.Length; i++)
{
if (char.IsUpper(result[i]))
{
counter++;
if (i > 1) //stops from adding a space at if string starts with Capital
{
result = result.Insert(i, " ");
i++; //Required** otherwise stuck in infinite
//add space loop over a single capital letter.
}
}
}
Binary Worrier의 답변에서 영감을 얻었습니다.결과는 다음과 같습니다.
/// <summary>
/// String Extension Method
/// Adds white space to strings based on Upper Case Letters
/// </summary>
/// <example>
/// strIn => "HateJPMorgan"
/// preserveAcronyms false => "Hate JP Morgan"
/// preserveAcronyms true => "Hate JPMorgan"
/// </example>
/// <param name="strIn">to evaluate</param>
/// <param name="preserveAcronyms" >determines saving acronyms (Optional => false) </param>
public static string AddSpaces(this string strIn, bool preserveAcronyms = false)
{
if (string.IsNullOrWhiteSpace(strIn))
return String.Empty;
var stringBuilder = new StringBuilder(strIn.Length * 2)
.Append(strIn[0]);
int i;
for (i = 1; i < strIn.Length - 1; i++)
{
var c = strIn[i];
if (Char.IsUpper(c) && (Char.IsLower(strIn[i - 1]) || (preserveAcronyms && Char.IsLower(strIn[i + 1]))))
stringBuilder.Append(' ');
stringBuilder.Append(c);
}
return stringBuilder.Append(strIn[i]).ToString();
}
10000000 반복 및 다양한 문자열 길이 및 조합을 실행하는 스톱워치를 사용하여 테스트했습니다.Binary Worrier의 답변보다 평균 50 % 빠릅니다.
private string GetProperName(string Header)
{
if (Header.ToCharArray().Where(c => Char.IsUpper(c)).Count() == 1)
{
return Header;
}
else
{
string ReturnHeader = Header[0].ToString();
for(int i=1; i<Header.Length;i++)
{
if (char.IsLower(Header[i-1]) && char.IsUpper(Header[i]))
{
ReturnHeader += " " + Header[i].ToString();
}
else
{
ReturnHeader += Header[i].ToString();
}
}
return ReturnHeader;
}
return Header;
}
여기에는 두문자어와 복수형이 포함되며 허용되는 답변보다 약간 빠릅니다.
public string Sentencify(string value)
{
if (string.IsNullOrWhiteSpace(value))
return string.Empty;
string final = string.Empty;
for (int i = 0; i < value.Length; i++)
{
if (i != 0 && Char.IsUpper(value[i]))
{
if (!Char.IsUpper(value[i - 1]))
final += " ";
else if (i < (value.Length - 1))
{
if (!Char.IsUpper(value[i + 1]) && !((value.Length >= i && value[i + 1] == 's') ||
(value.Length >= i + 1 && value[i + 1] == 'e' && value[i + 2] == 's')))
final += " ";
}
}
final += value[i];
}
return final;
}
다음 테스트를 통과합니다.
string test1 = "RegularOTs";
string test2 = "ThisStringHasNoSpacesASCIIButItDoesHaveCapitalsLINQ";
string test3 = "ThisStringHasNoSpacesButItDoesHaveCapitals";
로
fold
알려진 구현
Aggregate
:
public static string SpaceCapitals(this string arg) =>
new string(arg.Aggregate(new List<Char>(),
(accum, x) =>
{
if (Char.IsUpper(x) &&
accum.Any() &&
// prevent double spacing
accum.Last() != ' ' &&
// prevent spacing acronyms (ASCII, SCSI)
!Char.IsUpper(accum.Last()))
{
accum.Add(' ');
}
accum.Add(x);
return accum;
}).ToArray());
요청 외에도이 구현은 선행, 내부, 후행 공백 및 두문자어를 올바르게 저장합니다.
" SpacedWord " => " Spaced Word ",
"Inner Space" => "Inner Space",
"SomeACRONYM" => "Some ACRONYM".
소문자, 대문자 또는 숫자 뒤에 공백을 추가하는 간단한 방법입니다.
string AddSpacesToSentence(string value, bool spaceLowerChar = true, bool spaceDigitChar = true, bool spaceSymbolChar = false)
{
var result = "";
for (int i = 0; i < value.Length; i++)
{
char currentChar = value[i];
char nextChar = value[i < value.Length - 1 ? i + 1 : value.Length - 1];
if (spaceLowerChar && char.IsLower(currentChar) && !char.IsLower(nextChar))
{
result += value[i] + " ";
}
else if (spaceDigitChar && char.IsDigit(currentChar) && !char.IsDigit(nextChar))
{
result += value[i] + " ";
}
else if(spaceSymbolChar && char.IsSymbol(currentChar) && !char.IsSymbol(nextChar))
{
result += value[i];
}
else
{
result += value[i];
}
}
return result;
}
참고 URL :
https://stackoverflow.com/questions/272633/add-spaces-before-capital-letters
'programing' 카테고리의 다른 글
C ++에서 문자열의 문자 발생 수 계산 (0) | 2020.05.17 |
---|---|
스팸 봇에서 이메일을 숨기는 효과적인 방법 (0) | 2020.05.17 |
numpy 배열을 이미지로 변환하고 표시하는 방법은 무엇입니까? (0) | 2020.05.17 |
익명 유형 결과를 반환 하시겠습니까? (0) | 2020.05.16 |
Git은 일부 파일에서 변경 사항을 취소합니다. (0) | 2020.05.16 |