Làm cách nào để thay thế nhiều khoảng trắng bằng một khoảng trắng trong C #?

Làm cách nào tôi có thể thay thế nhiều khoảng trắng trong một chuỗi chỉ bằng một khoảng trắng trong C #?

Thí dụ:

1 2 3  4    5

sẽ là:

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, " ");

Tôi thích sử dụng:

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

Vì nó sẽ bắt chạy bất kỳ loại khoảng trắng nào (ví dụ: tab, dòng mới, v.v.) và thay thế chúng bằng một khoảng trắng.

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

Tôi nghĩ câu trả lời của Matt là tốt nhất, nhưng tôi không tin nó hoàn toàn đúng. Nếu bạn muốn thay thế dòng mới, bạn phải sử dụng:

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

Một cách tiếp cận khác sử dụng LINQ:

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

Nó đơn giản hơn nhiều so với tất cả:

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

Regex có thể khá chậm ngay cả với các tác vụ đơn giản. Điều này tạo ra một phương thức mở rộng có thể được sử dụng từ bất kỳ 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();
        }
    }

Nó sẽ được sử dụng như vậy:

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

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

Đối với những người không thích Regex, đây là một phương pháp sử dụng 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();
    }

Trong các thử nghiệm của tôi, phương pháp này trung bình nhanh hơn 16 lần với một chuỗi các chuỗi có kích thước từ nhỏ đến trung bình rất lớn, so với một Regex được biên dịch tĩnh. So với một Regex không được biên dịch hoặc không tĩnh, điều này thậm chí còn nhanh hơn.

Hãy nhớ rằng nó không xóa các khoảng trắng ở đầu hoặc cuối, chỉ có nhiều lần xuất hiện như vậy.

Bạn chỉ có thể làm điều này trong một giải pháp dòng!

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

Bạn có thể chọn dấu ngoặc khác (hoặc thậm chí các ký tự khác) nếu bạn muốn.

Đây là một phiên bản ngắn hơn, chỉ nên được sử dụng nếu bạn chỉ làm điều này một lần, vì nó tạo ra một thể hiện mới của Regexlớp mỗi khi nó được gọi.

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

Nếu bạn không quá quen thuộc với các biểu thức thông thường, đây là một lời giải thích ngắn:

Việc {2,}tìm kiếm regex cho ký tự đứng trước nó và tìm chuỗi con trong khoảng từ 2 đến không giới hạn.
Việc .Replace(temp, " ")thay thế tất cả các kết quả trong temp chuỗi bằng một khoảng trắng.

Nếu bạn muốn sử dụng nhiều lần, đây là một tùy chọn tốt hơn, vì nó tạo ra regex IL tại thời gian biên dịch:

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

không Regex, không Linq ... xóa các khoảng trắng ở đầu và cuối cũng như giảm bất kỳ phân đoạn không gian nhúng nào vào một không gian

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

kết quả: "0 1 2 3 4 5"

Giải thích các câu trả lời khác, theo Joel, và hy vọng sẽ cải thiện đôi chút khi tôi đi:

Bạn có thể làm điều này với Regex.Replace():

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

Hoặc với 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 (" ");

Tôi vừa viết một bài mới Joinmà tôi thích, vì vậy tôi nghĩ tôi sẽ trả lời lại, với nó:

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

Một trong những điều thú vị về điều này là nó hoạt động với các bộ sưu tập không phải là chuỗi, bằng cách gọi ToString () trên các phần tử. Cách sử dụng vẫn như cũ:

//...

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";

Tôi biết điều này khá cũ, nhưng đã chạy qua điều này trong khi cố gắng hoàn thành điều tương tự. Tìm thấy giải pháp này trong RegEx Buddy. Mẫu này sẽ thay thế tất cả các không gian đôi bằng các không gian đơn và cũng cắt bớt các không gian hàng đầu và dấu.

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

Hơi khó đọc một chút vì chúng ta đang xử lý không gian trống, do đó, một lần nữa với "khoảng trắng" được thay thế bằng "_".

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

Cấu trúc "(? M:" cho phép tùy chọn "nhiều dòng". Tôi thường muốn bao gồm bất kỳ tùy chọn nào tôi có thể trong chính mẫu để nó khép kín hơn.

Nhiều câu trả lời đang cung cấp đầu ra phù hợp nhưng với những người tìm kiếm màn trình diễn tốt nhất, tôi đã cải thiện câu trả lời của Nolanar (đó là câu trả lời tốt nhất cho hiệu suất) khoảng 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();
    }

}

Tôi có thể loại bỏ khoảng trắng với điều này

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

Sử dụng mẫu biểu thức chính

    [ ]+    #only space

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

thử phương pháp này

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();
}

sử dụng nó như thế này:

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

Đây là một sửa đổi nhỏ về câu trả lời ban đầu của Nolonar .

Kiểm tra xem ký tự không chỉ là khoảng trắng, mà là bất kỳ khoảng trắng nào, hãy sử dụng:

Nó sẽ thay thế bất kỳ ký tự khoảng trắng nào bằng một khoảng trắng.

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();
}

Skool cũ:

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 " ) );

Không sử dụng biểu thức chính quy:

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

OK để sử dụng trên các chuỗi ngắn, nhưng sẽ hoạt động kém trên các chuỗi dài có nhiều khoảng trống.

Kết hợp StringBuilder và Enumerable.Aggregate () làm phương thức mở rộng cho chuỗi:

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   ") + "\"");
    }
}

Đầu vào:

"1   Hello       World  2   "

Đầu ra:

"1 Hello World 2 "