关于regex：如何用C#中的单个空格替换多个空格？


How do I replace multiple spaces with a single space in C#?

如何用C_中的一个空格替换字符串中的多个空格？

例子：

1
1 2 3  4    5

将是：

1
1 2 3 4 5
相关讨论

我喜欢使用

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

自那时起，它将捕捉到任何种类的白色空间(E.G.Tabs，Newlines等)，并将它们与一个单一的空间放在一起。

相关讨论

1
2
3
RegexOptions options = RegexOptions.None;
Regex regex = new Regex("[ ]{2,}", options);    
tempo = regex.Replace(tempo,"");
相关讨论

ZZU1

相关讨论

我认为马特的回答是最好的，但我不相信它是正确的。如果你想换新的，你必须使用：

1
myString = Regex.Replace(myString, @"\s+","", RegexOptions.Multiline);
相关讨论

2.Another approach which uses linq:

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

这是非常简单的

1
while(str.Contains(" ")) str = str.Replace(" ","");
相关讨论

Regex甚至可以用简单的任务来减慢速度。这创造了一种可用于任何string的扩展方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    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();
        }
    }

这将是这样使用的：

1
2
3
string testValue ="This contains     too          much  whitespace."
testValue = testValue.ReduceWhitespace();
// testValue ="This contains too much whitespace."
1
myString = Regex.Replace(myString," {2,}","");

对于那些不喜欢Regex的人来说，这是一种使用StringBuilder的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    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();
    }

在我的测试中，这一方法在平均速度上是16个小时，与一个固定编译的规则相比，具有很大的中小条。与非编译或非静态规则相比，这甚至应该很快。

保持在脑海中，不排除引导或trailing spaces，只有这样的多重出现。

相关讨论

你可以简单地在一条线上解决这个问题！

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

如果你喜欢的话，你可以选择其他的布拉克(或甚至其他的特征)。

相关讨论

这是一个简短的版本，如果你只做这一次，就应该使用，就像它创建了一个新的Regex的论坛。

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

如果你不太熟悉常规表情，这是一个简短的解释：

使规则搜索以预先确定特征，并在2至不限时间内找到子特征。把所有比赛都放在一个空间的弦乐节奏中。

如果你想使用这多次，这是一个更好的选择，当它在编译时创建了规则：

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

没有雷克斯，没有林克清除引导和轨迹空间，以及减少任何嵌入式多空间段到一个空间

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

结果：0 1 2 3 4 5

相关讨论

Consolodating other answers，per Joel，and hopefully improving slightly as I go：

你可以用Regex.Replace()这样做：

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

(b)与国际劳工组织(劳工组织)合作；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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我喜欢，所以我想我会用它来回答

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

一件很酷的事是它用收集的不带弦乐的东西在元素上呼唤。使用还是一样的：

1
2
3
4
5
6
//...

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

我知道这是一个美丽的老东西，但它穿过这一点，试图实现同一件事。找到这个解决办法这一模式将把所有的双空间与单个空间以及三个牵引和跟踪空间结合起来。

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

自从我们和空气空间交往以来，这是一个小难题，所以它再次出现在"空间"中。

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

TheM"Constructure enables the"multi-line"option.我一般喜欢包括我能在模式中找到的任何选项，所以它更多地包含自我。

试试这个方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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();
}

用这个

1
string test = removeNestedWhitespaces("1 2 3  4    5".toCharArray());
相关讨论

我可以用这个卸下白色

1
2
3
while word.contains(" ")  //double space
   word = word.Replace(" ",""); //replace double space by single space.
word = word.trim(); //to remove single whitespces from start & end.
相关讨论

许多答案提供了正确的输出，但对于那些寻找最佳性能的人，我改进了诺拉纳的回答(这是最好的性能答案)，大约为10%。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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();
    }

}

MIX of Stringbuilder and Enumerable.Aggregate()as extension method for strings：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
"1   Hello       World  2  "

输出

1
"1 Hello World 2"

不使用常规表达式：

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

好的，用短弦，但会用很多的空间在长弦乐上表现得很差。

使用规则模式

1
2
3
    [ ]+    #only space

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

老Skool：

1
2
3
4
5
6
7
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" ) );
相关讨论