Wie ersetze ich mehrere Leerzeichen durch ein einzelnes Leerzeichen in C #?

Wie kann ich mehrere Leerzeichen in einer Zeichenfolge durch nur ein Leerzeichen in C # ersetzen?

Beispiel:

1 2 3  4    5

wäre:

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

Ich benutze gerne:

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

Da es Läufe von Leerzeichen aller Art (z. B. Tabulatoren, Zeilenumbrüche usw.) abfängt und durch ein einzelnes Leerzeichen ersetzt.

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

Ich denke, Matts Antwort ist die beste, aber ich glaube nicht, dass es ganz richtig ist. Wenn Sie Zeilenumbrüche ersetzen möchten, müssen Sie Folgendes verwenden:

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

Ein weiterer Ansatz, der LINQ verwendet:

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

Es ist viel einfacher als das alles:

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

Regex kann selbst bei einfachen Aufgaben ziemlich langsam sein. Dadurch wird eine Erweiterungsmethode erstellt, die von jedem verwendet werden kann 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();
        }
    }

Es würde als solches verwendet werden:

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

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

Für diejenigen, die nicht mögen Regex, ist hier eine Methode, die verwendet 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();
    }

In meinen Tests war diese Methode mit einem sehr großen Satz kleiner bis mittlerer Zeichenfolgen im Durchschnitt 16-mal schneller als mit einem statisch kompilierten Regex. Im Vergleich zu einem nicht kompilierten oder nicht statischen Regex sollte dies noch schneller sein.

Beachten Sie, dass führende oder nachfolgende Leerzeichen nicht entfernt werden , sondern nur das mehrfache Auftreten solcher Leerzeichen.

Sie können dies einfach in einer einzeiligen Lösung tun!

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

Sie können andere Klammern (oder sogar andere Zeichen) auswählen, wenn Sie möchten.

Dies ist eine kürzere Version, die nur verwendet werden sollte, wenn Sie dies nur einmal tun, da bei Regexjedem Aufruf eine neue Instanz der Klasse erstellt wird.

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

Wenn Sie mit regulären Ausdrücken nicht allzu vertraut sind, finden Sie hier eine kurze Erklärung:

Der {2,}Regex sucht nach dem Zeichen davor und findet Teilzeichenfolgen zwischen 2 und unbegrenzt oft.
Das .Replace(temp, " ")ersetzt alle Übereinstimmungen in der Zeichenfolgentemp durch ein Leerzeichen.

Wenn Sie dies mehrmals verwenden möchten, ist hier eine bessere Option, da die Regex-IL zur Kompilierungszeit erstellt wird:

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

no Regex, no Linq ... entfernt führende und nachfolgende Leerzeichen und reduziert alle eingebetteten Mehrfachraumsegmente auf ein Leerzeichen

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

Ergebnis: "0 1 2 3 4 5"

Andere Antworten trösten, per Joel, und hoffentlich leicht verbessern, wenn ich gehe:

Sie können dies tun mit Regex.Replace():

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

Oder mit 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 (" ");

Ich habe gerade eine neue geschrieben Join, die mir gefällt, also dachte ich, ich würde damit antworten:

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

Eines der coolen Dinge dabei ist, dass es mit Sammlungen funktioniert, die keine Zeichenfolgen sind, indem ToString () für die Elemente aufgerufen wird. Die Verwendung ist immer noch die gleiche:

//...

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

Ich weiß, dass dies ziemlich alt ist, bin aber darauf gestoßen, als ich versucht habe, fast das Gleiche zu erreichen. Diese Lösung wurde in RegEx Buddy gefunden. Dieses Muster ersetzt alle doppelten Leerzeichen durch einzelne Leerzeichen und schneidet auch führende und nachfolgende Leerzeichen.

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

Es ist ein wenig schwer zu lesen, da es sich um einen leeren Raum handelt. Hier werden also wieder die "Räume" durch ein "_" ersetzt.

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

Das Konstrukt "(? M:" aktiviert die Option "mehrzeilig". Im Allgemeinen möchte ich alle möglichen Optionen in das Muster selbst aufnehmen, damit es eigenständiger ist.

Viele Antworten liefern die richtige Ausgabe, aber für diejenigen, die nach den besten Leistungen suchen, habe ich Nolanars Antwort (die die beste Antwort für die Leistung war) um etwa 10% verbessert .

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

}

Ich kann damit Leerzeichen entfernen

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

Verwenden Sie das Regex-Muster

    [ ]+    #only space

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

Versuchen Sie diese Methode

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

benutze es so:

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

Hier ist eine geringfügige Änderung der ursprünglichen Antwort von Nolonar .

Überprüfen Sie Folgendes, um zu überprüfen, ob das Zeichen nicht nur ein Leerzeichen, sondern ein Leerzeichen ist:

Es werden mehrere Leerzeichen durch ein einzelnes Leerzeichen ersetzt.

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

Alte Schule:

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

Ohne reguläre Ausdrücke zu verwenden:

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

OK für kurze Saiten, aber für lange Saiten mit viel Leerzeichen schlecht.

Mix aus StringBuilder und Enumerable.Aggregate () als Erweiterungsmethode für Strings:

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

Eingang:

"1   Hello       World  2   "

Ausgabe:

"1 Hello World 2 "