.NET中刪除空白字串的10大方法

本文由碼農網 – 小峰原創翻譯，轉載請看清文末的轉載要求，歡迎參與我們的付費投稿計劃！

我們有無數方法可用於刪除字串中的所有空白，但是哪個更快呢？

介紹

我們有無數方法可用於刪除字串中的所有空白。大部分都能夠在絕大多數的用例中很好工作，但在某些對時間敏感的應用程式中，是否採用最快的方法可能就會造成天壤之別。

如果你問空白是什麼，那說起來還真是有些亂。許多人認為空白就是SPACE 字元（UnicodeU+0020，ASCII 32，HTML ），但它實際上還包括使得版式水平和垂直出現空格的所有字元。事實上，這是一整類定義為Unicode字元資料庫的字元。

本文所說的空白，不但指的是它的正確定義，同時也包括string.Replace(” “, “”)方法。

這裡的基準方法，將刪除所有頭尾和中間的空白。這就是文章標題中“所有空白”的含義。

背景

這篇文章一開始是出於我的好奇心。事實上，我並不需要用最快的演算法來刪除字串中的空白。

檢查空白字元

檢查空白字元很簡單。所有你需要的程式碼就是：

char wp = ' ';
char a = 'a';
Assert.True(char.IsWhiteSpace(wp));
Assert.False(char.IsWhiteSpace(a));

但是，當我實現手動優化刪除方法時，我意識到這並不像預期得那麼好。一些原始碼在微軟的參考原始碼庫的char.cs挖掘找到：

public static bool IsWhiteSpace(char c) {
    if (IsLatin1(c)) {
        return (IsWhiteSpaceLatin1(c));
    }
    return CharUnicodeInfo.IsWhiteSpace(c);
}

然後CharUnicodeInfo.IsWhiteSpace成了：

internal static bool IsWhiteSpace(char c)
{
    UnicodeCategory uc = GetUnicodeCategory(c);
    // In Unicode 3.0, U+2028 is the only character which is under the category "LineSeparator".
    // And U+2029 is th eonly character which is under the category "ParagraphSeparator".
    switch (uc) {
        case (UnicodeCategory.SpaceSeparator):
        case (UnicodeCategory.LineSeparator):
        case (UnicodeCategory.ParagraphSeparator):
            return (true);
    }

    return (false);
}

GetUnicodeCategory()方法呼叫InternalGetUnicodeCategory()方法，而且實際上相當快，但現在我們依次已經有了4個方法呼叫！以下這段程式碼是由一位評論者提供的，可用於快速實現定製版本和JIT預設內聯：

// whitespace detection method: very fast, a lot faster than Char.IsWhiteSpace
[MethodImpl(MethodImplOptions.AggressiveInlining)] // if it's not inlined then it will be slow!!!
public static bool isWhiteSpace(char ch) {
    // this is surprisingly faster than the equivalent if statement
    switch (ch) {
        case '\u0009': case '\u000A': case '\u000B': case '\u000C': case '\u000D':
        case '\u0020': case '\u0085': 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 '\u2028': case '\u2029': case '\u202F': case '\u205F': case '\u3000':
            return true;
        default:
            return false;
    }
}

刪除字串的不同方法

我用各種不同的方法來實現刪除字串中的所有空白。

分離合並法

這是我一直在用的一個非常簡單的方法。根據空格字元分離字串，但不包括空項，然後將產生的碎片重新合併到一起。這方法聽上去有點傻乎乎的，而事實上，乍一看，很像是一個非常浪費的解決方式：

public static string TrimAllWithSplitAndJoin(string str) {
    return string.Concat(str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));
}

LINQ

這是優雅地宣告式地實現這個過程的方法：

public static string TrimAllWithLinq(string str) {
    return new string(str.Where(c => !isWhiteSpace(c)).ToArray());
}

正規表示式

正規表示式是非常強大的力量，任何程式設計師都應該意識到這一點。

static Regex whitespace = new Regex(@"\s+", RegexOptions.Compiled);

public static string TrimAllWithRegex(string str) {
    return whitespace.Replace(str, "");
}

字元陣列原地轉換法

該方法將輸入的字串轉換成字元陣列，然後原地掃描字串去除空白字元（不建立中間緩衝區或字串）。最後，經過“刪減”的陣列會產生新的字串。

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];
        if (!isWhiteSpace(ch))
            src[dstIdx++] = ch;
    }
    return new string(src, 0, dstIdx);
}

字元陣列複製法

這種方法類似於字元陣列原地轉換法，但它使用Array.Copy複製連續非空白“字串”的同時跳過空格。最後，它將建立一個適當尺寸的字元陣列，並用相同的方式返回一個新的字串。

public static string TrimAllWithCharArrayCopy(string str) {
    var len = str.Length;
    var src = str.ToCharArray();
    int srcIdx = 0, dstIdx = 0, count = 0;
    for (int i = 0; i < len; i++) {
        if (isWhiteSpace(src[i])) {
            count = i - srcIdx;
            Array.Copy(src, srcIdx, src, dstIdx, count);
            srcIdx += count + 1;
            dstIdx += count;
            len--;
        }
    }
    if (dstIdx < len)
        Array.Copy(src, srcIdx, src, dstIdx, len - dstIdx);
    return new string(src, 0, len);
}

迴圈交換法

用程式碼實現迴圈，並使用StringBuilder類，通過依靠StringBuilder的內在優化來建立新的字串。為了避免任何其他因素對本實施產生干擾，不呼叫其他的方法，並且通過快取到本地變數避免訪問類成員。最後通過設定StringBuilder.Length將緩衝區調整到合適大小。

// Code suggested by http://www.codeproject.com/Members/TheBasketcaseSoftware
public static string TrimAllWithLexerLoop(string s) {
    int length = s.Length;
    var buffer = new StringBuilder(s);
    var dstIdx = 0;
    for (int index = 0; index < s.Length; index++) {
        char ch = s[index];
        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':
                length--;
                continue;
            default:
                break;
        }
        buffer[dstIdx++] = ch;
    }
    buffer.Length = length;
    return buffer.ToString();;
}

迴圈字元法

這種方法幾乎和前面的迴圈交換法相同，不過它採用if語句來呼叫isWhiteSpace()，而不是亂七八糟的switch伎倆 :)。

public static string TrimAllWithLexerLoopCharIsWhitespce(string s) {
    int length = s.Length;
    var buffer = new StringBuilder(s);
    var dstIdx = 0;
    for (int index = 0; index < s.Length; index++) {
        char currentchar = s[index];
        if (isWhiteSpace(currentchar))
            length--;
        else
            buffer[dstIdx++] = currentchar;
    }
    buffer.Length = length;
    return buffer.ToString();;
}

原地改變字串法（不安全）

這種方法使用不安全的字元指標和指標運算來原地改變字串。我不推薦這個方法，因為它打破了.NET框架在生產中的基本約定：字串是不可變的。

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

        /*// reset the string size
            * ONLY IT DIDN'T WORK! A GARBAGE COLLECTION ACCESS VIOLATION OCCURRED AFTER USING IT
            * SO I HAD TO RESORT TO RETURN A NEW STRING INSTEAD, WITH ONLY THE PERTINENT BYTES
            * IT WOULD BE A LOT FASTER IF IT DID WORK THOUGH...
        Int32 len = (Int32)(dst - pfixed);
        Int32* pi = (Int32*)pfixed;
        pi[-1] = len;
        pfixed[len] = '\0';*/
        return new string(pfixed, 0, (int)(dst - pfixed));
    }
}

原地改變字串法V2（不安全）

這種方法幾乎和前面那個相同，不過此處使用類似陣列的指標訪問。我很好奇，不知道這兩種哪種儲存訪問會更快。

public static unsafe string TrimAllWithStringInplaceV2(string str) {
    var len = str.Length;
    fixed (char* pStr = str) {
        int dstIdx = 0;
        for (int i = 0; i < len; i++)
            if (!isWhiteSpace(pStr[i]))
                pStr[dstIdx++] = pStr[i];
        // since the unsafe string length reset didn't work we need to resort to this slower compromise
        return new string(pStr, 0, dstIdx);
    }
}

String.Replace（“”，“”）

這種實現方法很天真，由於它只替換空格字元，所以它不使用空白的正確定義，因此會遺漏很多其他的空格字元。雖然它應該算是本文中最快的方法，但功能不及其他。

但如果你只需要去掉真正的空格字元，那就很難用純.NET寫出勝過string.Replace的程式碼。大多數字符串方法將回退到手動優化本地C ++程式碼。而String.Replace本身將用comstring.cpp呼叫C ++方法：

FCIMPL3(Object*, 
    COMString::ReplaceString, 
    StringObject* thisRefUNSAFE, 
    StringObject* oldValueUNSAFE, 
    StringObject* newValueUNSAFE)

下面是基準測試套件方法：

public static string TrimAllWithStringReplace(string str) {
    // This method is NOT functionaly equivalent to the others as it will only trim "spaces"
    // Whitespace comprises lots of other characters
    return str.Replace(" ", "");
}

許可證

這篇文章，以及任何相關的原始碼和檔案，依據The Code Project Open License (CPOL)的許可。