C #에서 여러 공백을 단일 공백으로 바꾸는 방법은 무엇입니까?

C #에서 문자열의 여러 공백을 하나의 공백으로 바꾸려면 어떻게해야합니까?

예:

1 2 3  4    5

될 것입니다 :

1 2 3 4 5

string sentence = "This is a sentence with multiple    spaces";
RegexOptions options = RegexOptions.None;
Regex regex = new Regex("[ ]{2,}", options);     
sentence = regex.Replace(sentence, " ");

나는 사용하고 싶다 :

myString = Regex.Replace(myString, @"\s+", " ");

모든 종류의 공백 (예 : 탭, 줄 바꿈 등)을 포착하여 단일 공백으로 바꿉니다.

string xyz = "1   2   3   4   5";
xyz = string.Join( " ", xyz.Split( new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries ));

나는 Matt의 대답이 최고라고 생각하지만 그것이 옳다고 믿지 않습니다. 줄 바꾸기를 바꾸려면 다음을 사용해야합니다.

myString = Regex.Replace(myString, @"\s+", " ", RegexOptions.Multiline);

LINQ를 사용하는 또 다른 접근법 :

 var list = str.Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));
 str = string.Join(" ", list);

그것은 모든 것보다 훨씬 간단합니다.

while(str.Contains("  ")) str = str.Replace("  ", " ");

간단한 작업으로도 정규식이 느려질 수 있습니다. 이것은 모든에서 사용할 수있는 확장 메소드를 작성합니다 string.

    public static class StringExtension
    {
        public static String ReduceWhitespace(this String value)
        {
            var newString = new StringBuilder();
            bool previousIsWhitespace = false;
            for (int i = 0; i < value.Length; i++)
            {
                if (Char.IsWhiteSpace(value[i]))
                {
                    if (previousIsWhitespace)
                    {
                        continue;
                    }

                    previousIsWhitespace = true;
                }
                else
                {
                    previousIsWhitespace = false;
                }

                newString.Append(value[i]);
            }

            return newString.ToString();
        }
    }

다음과 같이 사용됩니다.

string testValue = "This contains     too          much  whitespace."
testValue = testValue.ReduceWhitespace();
// testValue = "This contains too much whitespace."

myString = Regex.Replace(myString, " {2,}", " ");

를 좋아하지 않는 사람들 Regex을 위해 다음을 사용하는 방법이 있습니다 StringBuilder.

    public static string FilterWhiteSpaces(string input)
    {
        if (input == null)
            return string.Empty;

        StringBuilder stringBuilder = new StringBuilder(input.Length);
        for (int i = 0; i < input.Length; i++)
        {
            char c = input[i];
            if (i == 0 || c != ' ' || (c == ' ' && input[i - 1] != ' '))
                stringBuilder.Append(c);
        }
        return stringBuilder.ToString();
    }

필자의 테스트 에서이 방법은 정적 컴파일 된 Regex와 비교할 때 중소 규모의 매우 큰 문자열 집합으로 평균 16 배 빠릅니다. 컴파일되지 않은 또는 정적이 아닌 정규 표현식과 비교하면 훨씬 빠릅니다.

선행 또는 후행 공백을 제거 하지 않으며 그러한 경우는 여러 번만 발생합니다.

한 줄의 솔루션으로 간단히 할 수 있습니다!

string s = "welcome to  london";
s.Replace(" ", "()").Replace(")(", "").Replace("()", " ");

원하는 경우 다른 괄호 (또는 다른 문자)를 선택할 수 있습니다.

이 버전은 더 짧은 버전으로, Regex호출 할 때마다 클래스 의 새 인스턴스를 작성하므로 한 번만 수행하는 경우에만 사용해야합니다 .

temp = new Regex(" {2,}").Replace(temp, " "); 

정규 표현식에 익숙하지 않은 경우 간단한 설명은 다음과 같습니다.

는 {2,}그 앞에 문자의 정규식 검색을 만들고,이 무제한 번 사이의 문자열을 찾습니다.
그만큼.Replace(temp, " ") 공백 문자열 온도에서 모든 일치를 대체합니다.

이것을 여러 번 사용하려면 컴파일 타임에 정규식 IL을 생성하므로 다음과 같은 더 나은 옵션이 있습니다.

Regex singleSpacify = new Regex(" {2,}", RegexOptions.Compiled);
temp = singleSpacify.Replace(temp, " ");

정규식, Linq 없음, 선행 및 후행 공백을 제거하고 내장 된 여러 공백 세그먼트를 하나의 공백으로 줄입니다.

string myString = "   0 1 2  3   4               5  ";
myString = string.Join(" ", myString.Split(new char[] { ' ' }, 
StringSplitOptions.RemoveEmptyEntries));

결과 : "0 12 34 5"

Joel에 따라 다른 답변을 통합하고 내가 갈수록 약간 개선되기를 바랍니다.

당신은 이것을 할 수 있습니다 Regex.Replace():

string s = Regex.Replace (
    "   1  2    4 5", 
    @"[ ]{2,}", 
    " "
    );

또는과 String.Split():

static class StringExtensions
{
    public static string Join(this IList<string> value, string separator)
    {
        return string.Join(separator, value.ToArray());
    }
}

//...

string s = "     1  2    4 5".Split (
    " ".ToCharArray(), 
    StringSplitOptions.RemoveEmptyEntries
    ).Join (" ");

방금 Join내가 좋아 하는 새로운 것을 썼기 때문에 다시 답할 것이라고 생각했습니다.

public static string Join<T>(this IEnumerable<T> source, string separator)
{
    return string.Join(separator, source.Select(e => e.ToString()).ToArray());
}

이것에 대한 멋진 점 중 하나는 요소에서 ToString ()을 호출하여 문자열이 아닌 컬렉션에서 작동한다는 것입니다. 사용법은 여전히 ​​동일합니다.

//...

string s = "     1  2    4 5".Split (
    " ".ToCharArray(), 
    StringSplitOptions.RemoveEmptyEntries
    ).Join (" ");

      // Mysample string
            string str ="hi you           are          a demo";

            //Split the words based on white sapce
            var demo= str .Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));

            //Join the values back and add a single space in between
                    str = string.Join(" ", demo);

//output: string str ="hi you are a demo";

나는 이것이 꽤 오래되었다는 것을 알고 있지만 거의 같은 것을 성취하려고 노력하면서 이것을 가로 질러 달렸다. RegEx Buddy에서이 솔루션을 찾았습니다. 이 패턴은 모든 이중 공간을 단일 공간으로 대체하고 선행 및 후행 공간을 자릅니다.

pattern: (?m:^ +| +$|( ){2,})
replacement: $1

빈 공간을 다루기 때문에 읽기가 약간 어렵 기 때문에 여기서 "공백"이 "_"로 대체되었습니다.

pattern: (?m:^_+|_+$|(_){2,})  <-- don't use this, just for illustration.

"(? m :"구문은 "멀티 라인"옵션을 가능하게합니다. 일반적으로 패턴 자체에 포함 할 수있는 모든 옵션을 포함하여 더 독립적입니다.

많은 답변이 올바른 결과를 제공하지만 최고의 성능을 찾는 사람들을 위해 Nolanar의 답변 (성능에 가장 적합한 답변)을 약 10 % 개선했습니다.

public static string MergeSpaces(this string str)
{

    if (str == null)
    {
        return null;
    }
    else
    {
        StringBuilder stringBuilder = new StringBuilder(str.Length);

        int i = 0;
        foreach (char c in str)
        {
            if (c != ' ' || i == 0 || str[i - 1] != ' ')
                stringBuilder.Append(c);
            i++;
        }
        return stringBuilder.ToString();
    }

}

이 공백을 제거 할 수 있습니다

while word.contains("  ")  //double space
   word = word.Replace("  "," "); //replace double space by single space.
word = word.trim(); //to remove single whitespces from start & end.

정규식 패턴을 사용하십시오.

    [ ]+    #only space

   var text = Regex.Replace(inputString, @"[ ]+", " ");

이 방법을 사용해보십시오

private string removeNestedWhitespaces(char[] st)
{
    StringBuilder sb = new StringBuilder();
    int indx = 0, length = st.Length;
    while (indx < length)
    {
        sb.Append(st[indx]);
        indx++;
        while (indx < length && st[indx] == ' ')
            indx++;
        if(sb.Length > 1  && sb[0] != ' ')
            sb.Append(' ');
    }
    return sb.ToString();
}

다음과 같이 사용하십시오.

string test = removeNestedWhitespaces("1 2 3  4    5".toCharArray());

여기 약간의 수정이 있습니다 에 Nolonar 원래 대답은 .

문자가 공백이 아닌 공백인지 확인하려면 다음을 사용하십시오.

여러 공백 문자를 단일 공백으로 바꿉니다.

public static string FilterWhiteSpaces(string input)
{
    if (input == null)
        return string.Empty;

    var stringBuilder = new StringBuilder(input.Length);
    for (int i = 0; i < input.Length; i++)
    {
        char c = input[i];
        if (i == 0 || !char.IsWhiteSpace(c) || (char.IsWhiteSpace(c) && 
            !char.IsWhiteSpace(strValue[i - 1])))
            stringBuilder.Append(c);
    }
    return stringBuilder.ToString();
}

오래된 스쿨 :

string oldText = "   1 2  3   4    5     ";
string newText = oldText
                    .Replace("  ", " " + (char)22 )
                    .Replace( (char)22 + " ", "" )
                    .Replace( (char)22 + "", "" );

Assert.That( newText, Is.EqualTo( " 1 2 3 4 5 " ) );

정규식을 사용하지 않고 :

while (myString.IndexOf("  ", StringComparison.CurrentCulture) != -1)
{
    myString = myString.Replace("  ", " ");
}

짧은 문자열에는 사용할 수 있지만 공백이 많은 긴 문자열에서는 제대로 수행되지 않습니다.

문자열의 확장 메소드로서 StringBuilder 와 Enumerable.Aggregate ()의 혼합 :

using System;
using System.Linq;
using System.Text;

public static class StringExtension
{
    public static string StripSpaces(this string s)
    {
        return s.Aggregate(new StringBuilder(), (acc, c) =>
        {
            if (c != ' ' || acc.Length > 0 && acc[acc.Length-1] != ' ')
                acc.Append(c);

            return acc;
        }).ToString();
    }

    public static void Main()
    {
        Console.WriteLine("\"" + StringExtension.StripSpaces("1   Hello       World  2   ") + "\"");
    }
}

입력:

"1   Hello       World  2   "

산출:

"1 Hello World 2 "