Cara efisien untuk menghapus SEMUA spasi putih dari String?

Saya menelepon API REST dan menerima kembali respons XML. Ini mengembalikan daftar nama ruang kerja, dan saya sedang menulis IsExistingWorkspace()metode cepat . Karena semua ruang kerja terdiri dari karakter yang berdekatan tanpa spasi, saya mengasumsikan cara termudah untuk mengetahui apakah ruang kerja tertentu ada dalam daftar adalah dengan menghapus semua spasi putih (termasuk baris baru) dan melakukan ini (XML adalah string yang diterima dari web permintaan):

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

Saya tahu ini peka huruf besar-kecil, dan saya mengandalkan itu. Saya hanya perlu cara untuk menghapus semua spasi putih dalam string secara efisien. Saya tahu RegEx dan LINQ dapat melakukannya, tetapi saya terbuka untuk ide-ide lain. Saya kebanyakan hanya khawatir tentang kecepatan.

Ini adalah cara tercepat yang saya tahu, meskipun Anda mengatakan Anda tidak ingin menggunakan ekspresi reguler:

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

Saya punya cara alternatif tanpa regexp, dan tampaknya berkinerja cukup baik. Ini adalah kelanjutan jawaban Brandon Moretz:

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

Saya mengujinya dalam unit test sederhana:

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

Untuk 1.000.000 percobaan, opsi pertama (tanpa regexp) berjalan dalam waktu kurang dari satu detik (700 ms pada mesin saya), dan yang kedua membutuhkan 3,5 detik.

Coba ganti metode string di C #.

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

Solusi saya adalah dengan menggunakan Split dan Gabung dan ini sangat cepat, bahkan yang tercepat dari jawaban teratas di sini.

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

Pengaturan waktu untuk 10.000 loop pada string sederhana dengan spasi dan baris baru tab

• split / gabung = 60 milidetik
• linq chararray = 94 milidetik
• regex = 437 milidetik

Perbaiki ini dengan membungkusnya dalam metode untuk memberikan arti, dan juga menjadikannya metode ekstensi saat kita berada di ...

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

Membangun berdasarkan jawaban Henks Saya telah membuat beberapa metode pengujian dengan jawabannya dan beberapa metode yang ditambahkan dan lebih dioptimalkan. Saya menemukan hasil yang berbeda berdasarkan ukuran string input. Karena itu, saya telah menguji dengan dua set hasil. Dalam metode tercepat, sumber tertaut memiliki cara yang lebih cepat. Tapi, karena ini dicirikan sebagai tidak aman saya telah meninggalkan ini.

Input string yang panjang:

1. InPlaceCharArray: 2021 ms ( jawaban Sunsetquest ) - ( Sumber asli )
2. String split lalu gabung: 4277ms ( jawaban Kernowcode )
3. Pembaca string: 6082 ms
4. LINQ menggunakan char.IsWhitespace asli: 7357 ms
5. LINQ: 7746 ms ( jawaban Henk )
6. ForLoop: 32320 ms
7. RegexCompiled: 37157 ms
8. Regex: 42940 ms

Hasil input string pendek:

1. InPlaceCharArray: 108 ms ( jawaban Sunsetquest ) - ( Sumber asli )
2. String split lalu gabung: 294 ms ( jawaban Kernowcode )
3. Pembaca string: 327 ms
4. ForLoop: 343 ms
5. LINQ menggunakan char.IsWhitespace asli: 624 ms
6. LINQ: 645ms ( jawaban Henk )
7. RegexCompiled: 1671 ms
8. Regex: 2599 ms

Kode :

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

Tes :

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

Sunting : Diuji liner yang bagus dari Kernowcode.

Hanya sebuah alternatif karena terlihat cukup bagus :) - CATATAN: Jawaban Henks adalah yang tercepat dari ini.

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

Menguji 1.000.000 loop aktif "This is a simple Test"

Metode ini = 1,74 detik
Regex = 2,58 detik
new String(Henks) = 0,82

Saya menemukan artikel bagus tentang ini di CodeProject oleh Felipe Machado (dengan bantuan oleh Richard Robertson )

Dia menguji sepuluh metode berbeda. Yang ini adalah versi tercepat yang tidak aman ...

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

Dan versi aman tercepat ...

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

Ada juga beberapa tolok ukur independen yang bagus pada Stack Overflow oleh Stian Standahl yang juga menunjukkan bagaimana fungsi Felipe sekitar 300% lebih cepat daripada fungsi tercepat berikutnya.

Jika Anda membutuhkan kinerja luar biasa, Anda harus menghindari LINQ dan ekspresi reguler dalam kasus ini. Saya melakukan beberapa pembandingan kinerja, dan tampaknya jika Anda ingin menghapus ruang putih dari awal dan akhir string, string.Trim () adalah fungsi utama Anda.

Jika Anda perlu menghapus semua spasi putih dari string, metode berikut ini berfungsi paling cepat dari semua yang telah diposting di sini:

    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 berlebihan; cukup gunakan ekstensi pada string (terima kasih Henk). Ini sepele dan seharusnya menjadi bagian dari kerangka kerja. Bagaimanapun, ini implementasi saya:

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

Berikut ini adalah alternatif linier sederhana untuk solusi RegEx. Saya tidak yakin mana yang lebih cepat; Anda harus membandingkannya.

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

Saya perlu mengganti spasi putih dalam string dengan spasi, tetapi tidak menduplikasi spasi. misalnya, saya perlu mengonversi sesuatu seperti yang berikut:

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

untuk

"a b c d e"

Saya menggunakan metode berikut

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

Saya menganggap respons XML Anda terlihat seperti ini:

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

Cara terbaik untuk memproses XML adalah dengan menggunakan parser XML, seperti LINQ ke XML :

var doc = XDocument.Parse(xml);

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

Inilah varian lain:

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

Seperti sebagian besar solusi lainnya, saya belum melakukan tes benchmark lengkap, tetapi ini cukup berhasil untuk tujuan saya.

Kita bisa menggunakan:

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

Saya telah menemukan hasil yang berbeda untuk menjadi kenyataan. Saya mencoba mengganti semua spasi putih dengan satu ruang dan regex sangat lambat.

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

Apa yang bekerja paling optimal untuk saya (di C ++ cli) adalah:

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

Saya mencoba rutin di atas terlebih dahulu dengan mengganti setiap karakter secara terpisah, tetapi harus beralih ke melakukan substring untuk bagian non-spasi. Saat melamar ke 1.200.000 karakter string:

• rutin di atas menyelesaikannya dalam 25 detik
• penggantian karakter rutin di atas + terpisah dalam 95 detik
• regex dibatalkan setelah 15 menit.