Effiziente Möglichkeit, ALLE Leerzeichen aus dem String zu entfernen?

Ich rufe eine REST-API auf und erhalte eine XML-Antwort zurück. Es gibt eine Liste der Namen eines Arbeitsbereichs zurück, und ich schreibe eine schnelle IsExistingWorkspace()Methode. Da alle Arbeitsbereiche aus zusammenhängenden Zeichen ohne Leerzeichen bestehen, gehe ich davon aus, dass der einfachste Weg, um herauszufinden, ob sich ein bestimmter Arbeitsbereich in der Liste befindet, darin besteht, alle Leerzeichen (einschließlich Zeilenumbrüche) zu entfernen und dies zu tun (XML ist die vom Web empfangene Zeichenfolge) Anfrage):

XML.Contains("<name>" + workspaceName + "</name>");

Ich weiß, dass zwischen Groß- und Kleinschreibung unterschieden wird, und darauf verlasse ich mich. Ich brauche nur eine Möglichkeit, alle Leerzeichen in einem String effizient zu entfernen. Ich weiß, dass RegEx und LINQ das können, aber ich bin offen für andere Ideen. Ich mache mir meistens nur Sorgen um die Geschwindigkeit.

Dies ist der schnellste Weg, den ich kenne, obwohl Sie sagten, Sie wollten keine regulären Ausdrücke verwenden:

Regex.Replace(XML, @"\s+", "")

Ich habe einen alternativen Weg ohne Regexp, und es scheint ziemlich gut zu funktionieren. Es ist eine Fortsetzung der Antwort von Brandon Moretz:

 public static string RemoveWhitespace(this string input)
 {
    return new string(input.ToCharArray()
        .Where(c => !Char.IsWhiteSpace(c))
        .ToArray());
 }

Ich habe es in einem einfachen Unit-Test getestet:

[Test]
[TestCase("123 123 1adc \n 222", "1231231adc222")]
public void RemoveWhiteSpace1(string input, string expected)
{
    string s = null;
    for (int i = 0; i < 1000000; i++)
    {
        s = input.RemoveWhitespace();
    }
    Assert.AreEqual(expected, s);
}

[Test]
[TestCase("123 123 1adc \n 222", "1231231adc222")]
public void RemoveWhiteSpace2(string input, string expected)
{
    string s = null;
    for (int i = 0; i < 1000000; i++)
    {
        s = Regex.Replace(input, @"\s+", "");
    }
    Assert.AreEqual(expected, s);
}

Bei 1.000.000 Versuchen dauert die erste Option (ohne regulären Ausdruck) weniger als eine Sekunde (700 ms auf meinem Computer), und die zweite dauert 3,5 Sekunden.

Versuchen Sie die Ersetzungsmethode der Zeichenfolge in C #.

XML.Replace(" ", string.Empty);

Meine Lösung besteht darin, Split and Join zu verwenden, und es ist überraschend schnell, tatsächlich die schnellste der Top-Antworten hier.

str = string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));

Timings für 10.000 Schleifen auf einfachen Zeichenfolgen mit Leerzeichen inkl. Neuen Zeilen und Tabulatoren

• split / join = 60 Millisekunden
• linq chararray = 94 Millisekunden
• Regex = 437 Millisekunden

Verbessern Sie dies, indem Sie es in eine Methode einwickeln, um ihm eine Bedeutung zu geben, und machen Sie es auch zu einer Erweiterungsmethode, während wir gerade dabei sind ...

public static string RemoveWhitespace(this string str) {
    return string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));
}

Aufbauend auf Henks Antwort ich einige Testmethoden mit seiner Antwort erstellt und einige hinzugefügte, optimierte Methoden. Ich habe festgestellt, dass die Ergebnisse je nach Größe der Eingabezeichenfolge unterschiedlich sind. Deshalb habe ich mit zwei Ergebnismengen getestet. Bei der schnellsten Methode hat die verknüpfte Quelle einen noch schnelleren Weg. Aber da es als unsicher eingestuft wird, habe ich dies weggelassen.

Lange Eingabezeichenfolge Ergebnisse:

1. InPlaceCharArray: 2021 ms ( Antwort von Sunsetquest ) - ( Originalquelle )
2. String teilen und dann verbinden: 4277ms ( Antwort von Kernowcode )
3. String-Leser: 6082 ms
4. LINQ mit nativem char.IsWhitespace: 7357 ms
5. LINQ: 7746 ms (Henks Antwort )
6. ForLoop: 32320 ms
7. RegexCompiled: 37157 ms
8. Regex: 42940 ms

Kurze Ergebnisse der Eingabezeichenfolge:

1. InPlaceCharArray: 108 ms ( Antwort von Sunsetquest ) - ( Originalquelle )
2. String teilen, dann verbinden: 294 ms ( Antwort von Kernowcode )
3. String-Leser: 327 ms
4. ForLoop: 343 ms
5. LINQ mit nativem char.IsWhitespace: 624 ms
6. LINQ: 645 ms (Henks Antwort )
7. RegexCompiled: 1671 ms
8. Regex: 2599 ms

Code :

public class RemoveWhitespace
{
    public static string RemoveStringReader(string input)
    {
        var s = new StringBuilder(input.Length); // (input.Length);
        using (var reader = new StringReader(input))
        {
            int i = 0;
            char c;
            for (; i < input.Length; i++)
            {
                c = (char)reader.Read();
                if (!char.IsWhiteSpace(c))
                {
                    s.Append(c);
                }
            }
        }

        return s.ToString();
    }

    public static string RemoveLinqNativeCharIsWhitespace(string input)
    {
        return new string(input.ToCharArray()
            .Where(c => !char.IsWhiteSpace(c))
            .ToArray());
    }

    public static string RemoveLinq(string input)
    {
        return new string(input.ToCharArray()
            .Where(c => !Char.IsWhiteSpace(c))
            .ToArray());
    }

    public static string RemoveRegex(string input)
    {
        return Regex.Replace(input, @"\s+", "");
    }

    private static Regex compiled = new Regex(@"\s+", RegexOptions.Compiled);
    public static string RemoveRegexCompiled(string input)
    {
        return compiled.Replace(input, "");
    }

    public static string RemoveForLoop(string input)
    {
        for (int i = input.Length - 1; i >= 0; i--)
        {
            if (char.IsWhiteSpace(input[i]))
            {
                input = input.Remove(i, 1);
            }
        }
        return input;
    }

    public static string StringSplitThenJoin(this string str)
    {
        return string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));
    }

    public static string RemoveInPlaceCharArray(string input)
    {
        var len = input.Length;
        var src = input.ToCharArray();
        int dstIdx = 0;
        for (int i = 0; i < len; i++)
        {
            var ch = src[i];
            switch (ch)
            {
                case '\u0020':
                case '\u00A0':
                case '\u1680':
                case '\u2000':
                case '\u2001':
                case '\u2002':
                case '\u2003':
                case '\u2004':
                case '\u2005':
                case '\u2006':
                case '\u2007':
                case '\u2008':
                case '\u2009':
                case '\u200A':
                case '\u202F':
                case '\u205F':
                case '\u3000':
                case '\u2028':
                case '\u2029':
                case '\u0009':
                case '\u000A':
                case '\u000B':
                case '\u000C':
                case '\u000D':
                case '\u0085':
                    continue;
                default:
                    src[dstIdx++] = ch;
                    break;
            }
        }
        return new string(src, 0, dstIdx);
    }
}

Tests :

[TestFixture]
public class Test
{
    // Short input
    //private const string input = "123 123 \t 1adc \n 222";
    //private const string expected = "1231231adc222";

    // Long input
    private const string input = "123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222";
    private const string expected = "1231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc222";

    private const int iterations = 1000000;

    [Test]
    public void RemoveInPlaceCharArray()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveInPlaceCharArray(input);
        }

        stopwatch.Stop();
        Console.WriteLine("InPlaceCharArray: " + stopwatch.ElapsedMilliseconds + " ms");
        Assert.AreEqual(expected, s);
    }

    [Test]
    public void RemoveStringReader()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveStringReader(input);
        }

        stopwatch.Stop();
        Console.WriteLine("String reader: " + stopwatch.ElapsedMilliseconds + " ms");
        Assert.AreEqual(expected, s);
    }

    [Test]
    public void RemoveLinqNativeCharIsWhitespace()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveLinqNativeCharIsWhitespace(input);
        }

        stopwatch.Stop();
        Console.WriteLine("LINQ using native char.IsWhitespace: " + stopwatch.ElapsedMilliseconds + " ms");
        Assert.AreEqual(expected, s);
    }

    [Test]
    public void RemoveLinq()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveLinq(input);
        }

        stopwatch.Stop();
        Console.WriteLine("LINQ: " + stopwatch.ElapsedMilliseconds + " ms");
        Assert.AreEqual(expected, s);
    }

    [Test]
    public void RemoveRegex()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveRegex(input);
        }

        stopwatch.Stop();
        Console.WriteLine("Regex: " + stopwatch.ElapsedMilliseconds + " ms");

        Assert.AreEqual(expected, s);
    }

    [Test]
    public void RemoveRegexCompiled()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveRegexCompiled(input);
        }

        stopwatch.Stop();
        Console.WriteLine("RegexCompiled: " + stopwatch.ElapsedMilliseconds + " ms");

        Assert.AreEqual(expected, s);
    }

    [Test]
    public void RemoveForLoop()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveForLoop(input);
        }

        stopwatch.Stop();
        Console.WriteLine("ForLoop: " + stopwatch.ElapsedMilliseconds + " ms");

        Assert.AreEqual(expected, s);
    }

    [TestMethod]
    public void StringSplitThenJoin()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.StringSplitThenJoin(input);
        }

        stopwatch.Stop();
        Console.WriteLine("StringSplitThenJoin: " + stopwatch.ElapsedMilliseconds + " ms");

        Assert.AreEqual(expected, s);
    }
}

Bearbeiten : Getestet einen schönen Einzeiler von Kernowcode.

Nur eine Alternative, weil es ganz gut aussieht :) - HINWEIS : Henks Antwort ist die schnellste davon.

input.ToCharArray()
 .Where(c => !Char.IsWhiteSpace(c))
 .Select(c => c.ToString())
 .Aggregate((a, b) => a + b);

Testen von 1.000.000 Schleifen "This is a simple Test"

Diese Methode = 1,74 Sekunden
Regex = 2,58 Sekunden
new String(Henks) = 0,82

Ich habe auf CodeProject von Felipe Machado (mit Hilfe von Richard Robertson ) eine schöne Zusammenfassung dazu gefunden.

Er testete zehn verschiedene Methoden. Dies ist die schnellste unsichere Version ...

public static unsafe string TrimAllWithStringInplace(string str) {
    fixed (char* pfixed = str) {
        char* dst = pfixed;
        for (char* p = pfixed; *p != 0; p++)

            switch (*p) {

                case '\u0020': case '\u00A0': case '\u1680': case '\u2000': case '\u2001':

                case '\u2002': case '\u2003': case '\u2004': case '\u2005': case '\u2006':

                case '\u2007': case '\u2008': case '\u2009': case '\u200A': case '\u202F':

                case '\u205F': case '\u3000': case '\u2028': case '\u2029': case '\u0009':

                case '\u000A': case '\u000B': case '\u000C': case '\u000D': case '\u0085':
                    continue;

                default:
                    *dst++ = *p;
                    break;
            }

        return new string(pfixed, 0, (int)(dst - pfixed));
    }
}

Und die schnellste sichere Version ...

public static string TrimAllWithInplaceCharArray(string str) {

    var len = str.Length;
    var src = str.ToCharArray();
    int dstIdx = 0;

    for (int i = 0; i < len; i++) {
        var ch = src[i];

        switch (ch) {

            case '\u0020': case '\u00A0': case '\u1680': case '\u2000': case '\u2001':

            case '\u2002': case '\u2003': case '\u2004': case '\u2005': case '\u2006':

            case '\u2007': case '\u2008': case '\u2009': case '\u200A': case '\u202F':

            case '\u205F': case '\u3000': case '\u2028': case '\u2029': case '\u0009':

            case '\u000A': case '\u000B': case '\u000C': case '\u000D': case '\u0085':
                continue;

            default:
                src[dstIdx++] = ch;
                break;
        }
    }
    return new string(src, 0, dstIdx);
}

Es gibt auch einige nette unabhängige Benchmarks zu Stack Overflow von Stian Standahl, die auch zeigen, dass Felipes Funktion etwa 300% schneller ist als die nächstschnellste Funktion.

Wenn Sie eine hervorragende Leistung benötigen, sollten Sie in diesem Fall LINQ und reguläre Ausdrücke vermeiden. Ich habe ein Performance-Benchmarking durchgeführt, und es scheint, dass string.Trim () Ihre ultimative Funktion ist, wenn Sie Leerzeichen vom Anfang und Ende des Strings entfernen möchten.

Wenn Sie alle Leerzeichen von einer Zeichenfolge entfernen müssen, funktioniert die folgende Methode am schnellsten von allen hier veröffentlichten:

    public static string RemoveWhitespace(this string input)
    {
        int j = 0, inputlen = input.Length;
        char[] newarr = new char[inputlen];

        for (int i = 0; i < inputlen; ++i)
        {
            char tmp = input[i];

            if (!char.IsWhiteSpace(tmp))
            {
                newarr[j] = tmp;
                ++j;
            }
        }
        return new String(newarr, 0, j);
    }

Regex ist übertrieben; Verwenden Sie einfach die Erweiterung für die Zeichenfolge (danke Henk). Dies ist trivial und sollte Teil des Rahmens sein. Wie auch immer, hier ist meine Implementierung:

public static partial class Extension
{
    public static string RemoveWhiteSpace(this string self)
    {
        return new string(self.Where(c => !Char.IsWhiteSpace(c)).ToArray());
    }
}

Hier ist eine einfache lineare Alternative zur RegEx-Lösung. Ich bin mir nicht sicher, was schneller ist; Sie müssten es messen.

static string RemoveWhitespace(string input)
{
    StringBuilder output = new StringBuilder(input.Length);

    for (int index = 0; index < input.Length; index++)
    {
        if (!Char.IsWhiteSpace(input, index))
        {
            output.Append(input[index]);
        }
    }
    return output.ToString();
}

Ich musste Leerzeichen in einer Zeichenfolge durch Leerzeichen ersetzen, aber keine doppelten Leerzeichen. Ich musste beispielsweise Folgendes konvertieren:

"a b   c\r\n d\t\t\t e"

zu

"a b c d e"

Ich habe die folgende Methode verwendet

private static string RemoveWhiteSpace(string value)
{
    if (value == null) { return null; }
    var sb = new StringBuilder();

    var lastCharWs = false;
    foreach (var c in value)
    {
        if (char.IsWhiteSpace(c))
        {
            if (lastCharWs) { continue; }
            sb.Append(' ');
            lastCharWs = true;
        }
        else
        {
            sb.Append(c);
            lastCharWs = false;
        }
    }
    return sb.ToString();
}

Ich gehe davon aus, dass Ihre XML-Antwort folgendermaßen aussieht:

var xml = @"<names>
                <name>
                    foo
                </name>
                <name>
                    bar
                </name>
            </names>";

Der beste Weg, XML zu verarbeiten, ist die Verwendung eines XML-Parsers wie LINQ to XML :

var doc = XDocument.Parse(xml);

var containsFoo = doc.Root
                     .Elements("name")
                     .Any(e => ((string)e).Trim() == "foo");

Hier ist noch eine andere Variante:

public static string RemoveAllWhitespace(string aString)
{
  return String.Join(String.Empty, aString.Where(aChar => aChar !Char.IsWhiteSpace(aChar)));
}

Wie bei den meisten anderen Lösungen habe ich keine umfassenden Benchmark-Tests durchgeführt, aber dies funktioniert für meine Zwecke gut genug.

Wir können benutzen:

    public static string RemoveWhitespace(this string input)
    {
        if (input == null)
            return null;
        return new string(input.ToCharArray()
            .Where(c => !Char.IsWhiteSpace(c))
            .ToArray());
    }

Ich habe festgestellt, dass unterschiedliche Ergebnisse wahr sind. Ich versuche, alle Leerzeichen durch ein einzelnes Leerzeichen zu ersetzen, und der reguläre Ausdruck war extrem langsam.

return( Regex::Replace( text, L"\s+", L" " ) );

Was für mich (in C ++ cli) am besten funktioniert hat, war:

String^ ReduceWhitespace( String^ text )
{
  String^ newText;
  bool    inWhitespace = false;
  Int32   posStart = 0;
  Int32   pos      = 0;
  for( pos = 0; pos < text->Length; ++pos )
  {
    wchar_t cc = text[pos];
    if( Char::IsWhiteSpace( cc ) )
    {
      if( !inWhitespace )
      {
        if( pos > posStart ) newText += text->Substring( posStart, pos - posStart );
        inWhitespace = true;
        newText += L' ';
      }
      posStart = pos + 1;
    }
    else
    {
      if( inWhitespace )
      {
        inWhitespace = false;
        posStart = pos;
      }
    }
  }

  if( pos > posStart ) newText += text->Substring( posStart, pos - posStart );

  return( newText );
}

Ich habe die obige Routine zuerst versucht, indem ich jedes Zeichen separat ersetzt habe, musste aber auf Teilzeichenfolgen für die Nicht-Leerzeichen-Abschnitte umsteigen. Bei der Anwendung auf eine 1.200.000 Zeichenfolge:

• Die obige Routine erledigt dies in 25 Sekunden
• die obige Routine + separate Zeichenersetzung in 95 Sekunden
• Der Regex wurde nach 15 Minuten abgebrochen.